Mercurial Mercurial > oss > FCL > sf > mw > ipappprotocols / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Msrp/MsrpServer/src/CMSRPMessageHandler.cpp
branchMSRP_FrameWork
changeset 58 cdb720e67852
parent 25 505ad3f0ce5c
child 60 7634585a4347
equal deleted inserted replaced
25:505ad3f0ce5c 58:cdb720e67852 
    23 #include <s32mem.h>
 
    23 #include <s32mem.h>
 
    24 
    24 
    25 #include "MMSRPWriterObserver.h"
 
    25 #include "MMSRPWriterObserver.h"
 
    26 #include "CMSRPMessage.h"
 
    26 #include "CMSRPMessage.h"
 
    27 #include "CMSRPResponse.h"
 
    27 #include "CMSRPResponse.h"
 
       
    28 #include "CMSRPReport.h"
 
    28 #include "CMSRPByteRangeHeader.h"
 
    29 #include "CMSRPByteRangeHeader.h"
 
    29 #include "CMSRPToPathHeader.h"
 
    30 #include "CMSRPToPathHeader.h"
 
    30 #include "CMSRPFromPathHeader.h"
 
    31 #include "CMSRPFromPathHeader.h"
 
    31 #include "CMSRPMessageIdHeader.h"
 
    32 #include "CMSRPMessageIdHeader.h"
 
    32 #include "CMSRPSuccessReportHeader.h"
 
    33 #include "CMSRPSuccessReportHeader.h"
 
    35 #include "MSRPStrings.h"
 
    36 #include "MSRPStrings.h"
 
    36 #include "MsrpStrConsts.h"
 
    37 #include "MsrpStrConsts.h"
 
    37 #include "TMSRPUtil.h"
 
    38 #include "TMSRPUtil.h"
 
    38 #include "MMSRPConnection.h"
 
    39 #include "MMSRPConnection.h"
 
    39 #include "MMSRPMessageObserver.h"
 
    40 #include "MMSRPMessageObserver.h"
 
       
    41 #include "CMSRPStatusHeader.h"
 
    40 
    42 
    41 // Constants
 
    43 // Constants
 
    42 const TInt KEndlineConstLength = 10;
 
    44 const TInt KEndlineConstLength = 10;
 
    43 
    45 
    44 
    46 
   100         if( iMessage->IsContent() )
 
   102         if( iMessage->IsContent() )
 
   101             {
 
   103             {
 
   102             iContentPtr.Set(iMessage->Content());
 
   104             iContentPtr.Set(iMessage->Content());
 
   103             }
 
   105             }
 
   104         }    
   106         }    
       
   107     else if ( CMSRPReport::IsReport( aMessage ) )
 
       
   108         {
 
       
   109         iReport = CMSRPReport::InternalizeL( readStream );
 
       
   110         }
 
   105     else
 
   111     else
 
   106         {
 
   112         {
 
   107         User::Leave( KErrArgument );
 
   113         User::Leave( KErrArgument );
 
   108         }
 
   114         }
 
   109     
   115     
   110     iBuffer.CreateL( KMaxBufferSize );
 
   116     iBuffer.CreateL( KMaxBufferSize );
 
   111     iState = EIdle;
 
   117     iState = EIdle;
 
   112     MSRPStrings::OpenL();
 
   118     MSRPStrings::OpenL();
 
       
   119     
       
   120     iFs.Connect();
 
   113     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
 
   121     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
 
   114     }
 
   122     }
 
   115 
   123 
   116 
   124 
   117 void CMSRPMessageHandler::ConstructL( TMSRPMessageType aMessageType )
 
   125 void CMSRPMessageHandler::ConstructL( TMSRPMessageType aMessageType )
 
   126         iResponse = new ( ELeave ) CMSRPResponse();
 
   134         iResponse = new ( ELeave ) CMSRPResponse();
 
   127         }
 
   135         }
 
   128     else if( aMessageType == EMSRPReport )
 
   136     else if( aMessageType == EMSRPReport )
 
   129         {
 
   137         {
 
   130         // Since Reports are not supported now.. jus create a message class
 
   138         // Since Reports are not supported now.. jus create a message class
 
   131         iMessage = new ( ELeave ) CMSRPMessage();            
   139         iReport = new ( ELeave ) CMSRPReport();            
   132         }
 
   140         }
 
   133     else
 
   141     else
 
   134         {
 
   142         {
 
   135         // Maybe AUTH or some unrecognized request. For now just create a message class
 
   143         // Maybe AUTH or some unrecognized request. For now just create a message class
 
   136         iMessage = new ( ELeave ) CMSRPMessage();
 
   144         iMessage = new ( ELeave ) CMSRPMessage();
 
   138     
   146     
   139     iActiveMsgType = aMessageType;
 
   147     iActiveMsgType = aMessageType;
 
   140     iBuffer.CreateL( KSmallBuffer );
 
   148     iBuffer.CreateL( KSmallBuffer );
 
   141     iState = EIdle;    
   149     iState = EIdle;    
   142     MSRPStrings::OpenL();
 
   150     MSRPStrings::OpenL();
 
       
   151     iFs.Connect();
 
   143     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
 
   152     MSRPLOG( "CMSRPMessageHandler::ConstructL exit" )
 
   144     }
 
   153     }
 
   145 
   154 
   146 
   155 
   147 // -----------------------------------------------------------------------------
 
   156 // -----------------------------------------------------------------------------
 
   162 // Destructor
 
   171 // Destructor
 
   163 // -----------------------------------------------------------------------------
 
   172 // -----------------------------------------------------------------------------
 
   164 //
 
   173 //
 
   165 CMSRPMessageHandler::~CMSRPMessageHandler( )
 
   174 CMSRPMessageHandler::~CMSRPMessageHandler( )
 
   166     {
 
   175     {
 
       
   176     MSRPLOG2( "-> CMSRPMessageHandler::~CMSRPMessageHandler = %d", this )
 
   167     delete iMessage;
 
   177     delete iMessage;
 
   168     delete iResponse;
 
   178     delete iResponse;
 
   169     delete iFileBuffer;
 
   179     delete iFileBuffer;
 
       
   180     iSentChunks.ResetAndDestroy();
 
       
   181     iSentChunks.Close();
 
   170     iBuffer.Close();
 
   182     iBuffer.Close();
 
   171     MSRPStrings::Close();
 
   183     MSRPStrings::Close();
 
   172     iChunkList.ResetAndDestroy();
 
       
   173     iChunkList.Close();
 
       
   174     //iFile.Flush();
 
       
   175     iFile.Close();
 
   184     iFile.Close();
 
       
   185     MSRPLOG( "<- CMSRPMessageHandler::~CMSRPMessageHandler" )
 
   176     }
 
   186     }
 
   177 
   187 
   178 
   188 
   179 void CMSRPMessageHandler::AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, TPtrC8& /*aHeaderTypeAndValue*/ )
 
   189 void CMSRPMessageHandler::AddHeaderL( TMsrpHeaderType aHeaderType, TPtrC8& aHeaderValue, TPtrC8& /*aHeaderTypeAndValue*/ )
 
   180     {
 
   190     {
 
   181     MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )
 
   191     MSRPLOG( "CMSRPMessageHandler::AddHeaderL enter" )
 
   182     CMSRPMessageBase* messageBase = NULL;
 
   192     CMSRPMessageBase* messageBase = NULL;
 
   183     if( iResponse )
 
   193     if( iResponse )
 
   184         {
 
   194         {
 
   185         messageBase = iResponse;
 
   195         messageBase = iResponse;
 
       
   196         }
 
       
   197     else if ( iReport )
 
       
   198         {
 
       
   199         messageBase = iReport;
 
   186         }
 
   200         }
 
   187     else
 
   201     else
 
   188         {
 
   202         {
 
   189         messageBase = iMessage;
 
   203         messageBase = iMessage;
 
   190         }
 
   204         }
 
   262             messageBase->SetContentTypeHeader( CMSRPContentTypeHeader::NewL( aHeaderValue ) );
 
   276             messageBase->SetContentTypeHeader( CMSRPContentTypeHeader::NewL( aHeaderValue ) );
 
   263             break;
 
   277             break;
 
   264             }                
   278             }                
   265         case EStatus:        
   279         case EStatus:        
   266             {
 
   280             {
 
       
   281             TInt statusValue = TMSRPUtil::ConvertToNumber( aHeaderValue );
 
       
   282             messageBase->SetStatusHeader( CMSRPStatusHeader::NewL( statusValue ) );
 
   267             break; // required for reports only. Not handled now
 
   283             break; // required for reports only. Not handled now
 
   268             }              
   284             }              
       
   285             
   269         default:             
   286         default:             
   270             {
 
   287             {
 
   271             break;
 
   288             break;
 
   272             }                   
   289             }                   
   273         }
 
   290         }
 
   275     
   292     
   276     MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )
 
   293     MSRPLOG( "CMSRPMessageHandler::AddHeaderL exit" )
 
   277     }
 
   294     }
 
   278 
   295 
   279     
   296     
   280 void CMSRPMessageHandler::AddContentL( TPtrC8& aContent )
 
   297 void CMSRPMessageHandler::AddContentL( TPtrC8& aContent, TBool aByteRangeFound )
 
   281     {
 
   298     {
 
   282     MSRPLOG( "CMSRPMessageHandler::AddContentL enter" )
 
   299     MSRPLOG2( "CMSRPMessageHandler::AddContentL enter, instance = %d", this )
 
   283     if( iMessage )
 
   300     if( iMessage )
 
   284         {
 
   301         {
 
   285         if( iBuffer.Length() + aContent.Length() > iBuffer.MaxLength() )
 
   302         if ( aByteRangeFound )
 
   286             {
 
   303             {
 
   287             iBuffer.ReAllocL(iBuffer.Length() + aContent.Length());
 
   304             if( iBuffer.Length() + aContent.Length() > iBuffer.MaxLength() )
 
   288             iBuffer.Append(aContent);
 
   305                 {
 
       
   306                 HBufC8* combined = HBufC8::NewLC( iBuffer.Length() + aContent.Length() );
 
       
   307                 TPtr8 ptr = combined->Des();
 
       
   308                 ptr = iBuffer;
 
       
   309                 ptr.Append( aContent );
 
       
   310                 // must write to file
 
       
   311                 WriteMessageToFileL( ptr );
 
       
   312                 CleanupStack::PopAndDestroy( ); // combined
 
       
   313                 iBuffer.Zero();
 
       
   314                 }
 
       
   315             else
 
       
   316                 {
 
       
   317                 iBuffer.Append( aContent );
 
       
   318                 iCurrentNumberOfBytes = iBuffer.Length();
 
       
   319                 }
 
   289             }
 
   320             }
 
   290         else
 
   321         else
 
   291             {
 
   322             {
 
   292             iBuffer.Append(aContent);
 
   323             AppendMessageToFileL( aContent );
 
   293             }
 
   324             }
 
   294         }    
   325         }    
   295     MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )
 
   326     MSRPLOG( "CMSRPMessageHandler::AddContentL exit" )
 
   296     }
 
   327     }
 
   297 
   328 
   298 
   329 
   299 void CMSRPMessageHandler::SetTransactionId( TPtrC8& aTransactionId )
 
   330 void CMSRPMessageHandler::SetTransactionId( TDesC8& aTransactionId )
 
   300     {
 
   331     {
 
   301     MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )    
   332     MSRPLOG( "CMSRPMessageHandler::SetTransactionId enter" )
 
   302     iTransactionId = aTransactionId;    
   333     HBufC8* transactionId = HBufC8::NewL( aTransactionId.Length() );
 
       
   334     *transactionId = aTransactionId;
 
       
   335     iSentChunks.Append( transactionId );
 
   303     MSRPLOG( "CMSRPMessageHandler::SetTransactionId exit" )
 
   336     MSRPLOG( "CMSRPMessageHandler::SetTransactionId exit" )
 
   304     }
 
   337     }
 
   305 
   338 
   306 
   339 
   307 void CMSRPMessageHandler::SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& /*aStatusMessage*/ )
 
   340 void CMSRPMessageHandler::SetStatusOfResponseL( TPtrC8& aStatusCode, TPtrC8& /*aStatusMessage*/ )
 
   318     }
 
   351     }
 
   319 
   352 
   320 
   353 
   321 void CMSRPMessageHandler::EndOfMessageL( TMsrpMsgEndStatus aStatus )
 
   354 void CMSRPMessageHandler::EndOfMessageL( TMsrpMsgEndStatus aStatus )
 
   322     {
 
   355     {
 
   323     MSRPLOG( "CMSRPMessageHandler::EndOfMessageL enter" )  
   356     MSRPLOG2( "CMSRPMessageHandler::EndOfMessageL enter = %d", this )
 
   324     if( iMessage && iBuffer.Length() )
 
   357     MSRPLOG2( "CMSRPMessageHandler::EndOfMessageL enter = %d", aStatus )
 
   325         {
 
   358     iMessageEnding = aStatus;
 
   326         HBufC8* contentOfMessage = HBufC8::NewL( iBuffer.Length() );
 
   359     if( iMessage && iBuffer.Length() && ( aStatus == EMessageEnd ) )
 
   327         *contentOfMessage = iBuffer;
 
   360         {
 
   328         iMessage->SetContent( contentOfMessage );
 
   361         if ( !iTempFileName.Length() )
 
   329         iBuffer.Zero();
 
   362             {
 
   330         }
 
   363             HBufC8* contentOfMessage = HBufC8::NewL( iBuffer.Length() );
 
   331     iMsgEndStatus = aStatus;    
   364             *contentOfMessage = iBuffer;
 
       
   365             iMessage->SetContent( contentOfMessage );
 
       
   366             iBuffer.Zero();
 
       
   367             }
 
       
   368         else
 
       
   369             {
 
       
   370             WriteMessageToFileL( iBuffer );
 
       
   371             iBuffer.Zero();
 
       
   372             }
 
       
   373         }
 
       
   374     if ( aStatus == EMessageEnd )
 
       
   375         {
 
       
   376         iState = EMessageDone;
 
       
   377         }
 
       
   378     
       
   379     if( aStatus == EMessageTerminated )
 
       
   380         {
 
       
   381         iTerminateReceiving = ETrue;
 
       
   382         iState = ETerminated;
 
       
   383         }
 
       
   384         
   332     MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )
 
   385     MSRPLOG( "CMSRPMessageHandler::EndOfMessageL exit" )
 
   333     }
 
   386     }
 
   334 
   387 
   335 
   388 
   336 MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )
 
   389 MMSRPIncomingMessage::TMSRPMessageType CMSRPMessageHandler::MessageType( )
 
   339     MSRPLOG2("Message Type = %d", iActiveMsgType ); 
   392     MSRPLOG2("Message Type = %d", iActiveMsgType ); 
   340     return iActiveMsgType;
 
   393     return iActiveMsgType;
 
   341     }
 
   394     }
 
   342 
   395 
   343 
   396 
   344 CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( )
 
   397 CMSRPMessage* CMSRPMessageHandler::GetIncomingMessage( ) const
 
   345     {
 
   398     {
 
   346     MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  
   399     MSRPLOG( "CMSRPMessageHandler::GetIncomingMessage enter" )  
   347     if( iMessage )
 
   400     return iMessage;
 
   348         {
 
   401     }
 
   349         return iMessage;
 
   402 
   350         }
 
   403 void CMSRPMessageHandler::SendResponseL( MMSRPMessageObserver* aMessageObserver, 
   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 )
 
   404                                             MMSRPConnection& aConnection, TUint aResponseCode )
 
   405     {
 
   405     {
 
   406     MSRPLOG( "CMSRPMessageHandler::SendResponseL enter" )
 
   406     MSRPLOG( "CMSRPMessageHandler::SendResponseL enter" )
 
   407         
   407         
   408     iMSRPMessageObserver = aMessageObserver;
 
   408     iMSRPMessageObserver = aMessageObserver;
 
   419         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )
 
   419         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )
 
   420             {
 
   420             {
 
   421             sendResponse = EFalse;
 
   421             sendResponse = EFalse;
 
   422             }
 
   422             }
 
   423         else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) 
   423         else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()) 
   424                 && (aResponseCode == CMSRPResponse::EAllOk) )
 
   424                 && (aResponseCode == EAllOk) )
 
   425             {
 
   425             {
 
   426             sendResponse = EFalse;
 
   426             sendResponse = EFalse;
 
   427             }
 
   427             }
 
   428         CleanupStack::PopAndDestroy(frHeaderValue);
 
   428         CleanupStack::PopAndDestroy(frHeaderValue);
 
   429         }
 
   429         }
 
   430     
   430     
   431     if( !iMessage->ToPathHeader() || !iMessage->FromPathHeader() )
 
   431     if( !iMessage->ToPathHeader() || !iMessage->FromPathHeader() )
 
   432         {
 
   432         {
 
   433         aResponseCode = CMSRPResponse::EUnknownCode;
 
   433         aResponseCode = EUnknownCode;
 
   434         sendResponse = EFalse;
 
   434         sendResponse = EFalse;
 
   435         }
 
   435         }
 
   436     
   436     
   437     if(sendResponse)
 
   437     if(sendResponse)
 
   438         {
 
   438         {
 
   443         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );
 
   443         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );
 
   444         CleanupStack::PopAndDestroy(fromPathValue);
 
   444         CleanupStack::PopAndDestroy(fromPathValue);
 
   445         
   445         
   446         HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();
 
   446         HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();
 
   447         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );
 
   447         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );
 
   448         CleanupStack::PopAndDestroy(toPathValue);
 
   448         CleanupStack::PopAndDestroy(toPathValue);   
   449         
   449         
   450         iActiveMsgType = EMSRPResponse;
 
   450         iActiveMsgType = EMSRPResponse;
 
       
   451         iState = EIdle;
 
   451         aConnection.SendL( *this );
 
   452         aConnection.SendL( *this );
 
   452         }
 
   453         }
 
   453   
   454   
   454     MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )
 
   455     MSRPLOG( "CMSRPMessageHandler::SendResponseL exit" )
 
   455 	
   456     }
 
   456 	if( aResponseCode == CMSRPResponse::EAllOk )
 
   457 
   457         return ETrue;
 
   458 TBool CMSRPMessageHandler::SendReportL( 
   458     else
 
   459     MMSRPMessageObserver* aMessageObserver, 
   459         return EFalse;
 
   460     MMSRPConnection& aConnection, TUint aStatusCode )
 
   460     }
 
   461     {
 
   461 
   462     MSRPLOG( "CMSRPMessageHandler::SendReportL enter" )
 
   462 
   463     
   463 TBool CMSRPMessageHandler::IfResponseReqL()
 
   464     TBool sendReport = EFalse;
 
   464     {
 
   465     if ( iActiveMsgType == EMSRPResponse )
 
   465     TBool responseReq = ETrue;
 
   466         {
 
   466     if( iMessage->FailureReportHeader() )
 
   467         // currently sending a response
 
   467         {
 
   468         MSRPLOG( "CMSRPMessageHandler::SendReportL sendin a response..." )
 
   468         HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();
 
   469         return sendReport;
 
   469         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::ENo ).DesC() )
 
   470         }
 
   470             {
 
   471     iMSRPMessageObserver = aMessageObserver;
 
   471              responseReq = EFalse;
 
   472     if( iMessage->SuccessReportHeader() )
 
   472             }
 
   473         {
 
   473         else if( (frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC()))
 
   474         HBufC8* successHeaderValue = iMessage->SuccessReportHeader()->ToTextValueLC();
 
   474             {
 
   475         if( successHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() )
 
   475             responseReq = EFalse;
 
   476             {
 
   476             }
 
   477             MSRPLOG( "CMSRPMessageHandler::SendReportL report needed!" )
 
   477         CleanupStack::PopAndDestroy(frHeaderValue);     
   478             sendReport = ETrue;
 
   478         }
 
   479             }
 
   479     return responseReq;
 
   480         CleanupStack::PopAndDestroy( successHeaderValue );
 
   480     }
 
   481         }
 
   481 
   482         
       
   483     if ( sendReport )
 
       
   484         {
 
       
   485         iReport = new ( ELeave ) CMSRPReport( ) ;
 
       
   486         iReport->SetStatusHeader( CMSRPStatusHeader::NewL( aStatusCode ) );
 
       
   487 
       
   488         HBufC8* fromPathValue = iMessage->FromPathHeader()->ToTextValueLC();
 
       
   489         iReport->SetToPathHeader( CMSRPToPathHeader::DecodeL( *fromPathValue ) );
 
       
   490         CleanupStack::PopAndDestroy(fromPathValue);
 
       
   491         
       
   492         HBufC8* toPathValue = iMessage->ToPathHeader()->ToTextValueLC();
 
       
   493         iReport->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( *toPathValue ) );
 
       
   494         CleanupStack::PopAndDestroy(toPathValue);   
       
   495 
       
   496         HBufC8* messageId = iMessage->MessageIdHeader()->ToTextValueLC();
 
       
   497         iReport->SetMessageIdHeader( CMSRPMessageIdHeader::NewL( *messageId ) );
 
       
   498         CleanupStack::PopAndDestroy( messageId );   
       
   499         
       
   500         TInt size( 0 );
 
       
   501         if ( iTempFileName.Length() )
 
       
   502             {
 
       
   503             OpenTemporaryFileL( iTempFileName );
 
       
   504             iTempFile->Size( size );
 
       
   505             }
 
       
   506         else
 
       
   507             {
 
       
   508             size = iBuffer.Length();
 
       
   509             }
 
       
   510         CMSRPByteRangeHeader* byteRange = 
       
   511                 CMSRPByteRangeHeader::NewL( 1, size, size );
 
       
   512         iReport->SetByteRangeHeader( byteRange );
 
       
   513         
       
   514         iActiveMsgType = EMSRPReport;
 
       
   515         iState = EIdle;
 
       
   516         aConnection.SendL( *this );
 
       
   517         }
 
       
   518     MSRPLOG( "CMSRPMessageHandler::SendReportL exit" )
 
       
   519     return sendReport;
 
       
   520     }
 
   482 
   521 
   483 TDesC8& CMSRPMessageHandler::TransactionId( )
 
   522 TDesC8& CMSRPMessageHandler::TransactionId( )
 
   484     {
 
   523     {
 
   485     MSRPLOG( "CMSRPMessageHandler::TransactionId enter" )
 
   524     MSRPLOG( "CMSRPMessageHandler::TransactionId enter" )
 
   486     return iTransactionId;
 
   525     return *iSentChunks[ iSentChunks.Count() - 1 ];
 
   487     }
 
   526     }
 
   488 
   527 
   489 
   528 
   490 CMSRPResponse* CMSRPMessageHandler::GetIncomingResponse( )
 
   529 CMSRPResponse* CMSRPMessageHandler::GetIncomingResponse( ) const
 
   491     {
 
   530     {
 
   492     MSRPLOG( "CMSRPMessageHandler::GetIncomingResponse enter" )
 
   531     MSRPLOG( "CMSRPMessageHandler::GetIncomingResponse enter" )
 
   493     if( iResponse )
 
   532     return iResponse;
 
   494         {
 
   533     }
 
   495         return iResponse;
 
   534 
   496         }
 
   535 CMSRPReport* CMSRPMessageHandler::GetIncomingReport( ) const
 
   497     return NULL;
 
   536     {
 
   498     }
 
   537     MSRPLOG( "-> CMSRPMessageHandler::GetIncomingReport" )
 
   499 
   538     return iReport;
 
       
   539     }
 
   500 
   540 
   501 void CMSRPMessageHandler::SendMessageL( MMSRPConnection& aConnection )
 
   541 void CMSRPMessageHandler::SendMessageL( MMSRPConnection& aConnection )
 
   502     {
 
   542     {
 
   503     MSRPLOG( "CMSRPMessageHandler::SendMessageL enter" )    
   543     MSRPLOG( "CMSRPMessageHandler::SendMessageL enter" )    
   504     iActiveMsgType = EMSRPMessage;
 
   544     iActiveMsgType = EMSRPMessage;
 
       
   545     isSending = ETrue;
 
       
   546     if ( iMessage->IsFile() )
 
       
   547         {
 
       
   548         User::LeaveIfError(iFile.Open(iFs, iMessage->GetFileName(), EFileShareReadersOrWriters)); 
       
   549         iFile.Size(iFileSize);
 
       
   550         iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);            
       
   551         FillFileBufferL();
 
       
   552         }
 
       
   553     else
 
       
   554         {
 
       
   555         iContentPtr.Set( iMessage->Content() );
 
       
   556         }
 
       
   557         
   505     aConnection.SendL( *this );
 
   558     aConnection.SendL( *this );
 
   506     MSRPLOG( "CMSRPMessageHandler::SendMessageL exit" )
 
   559     MSRPLOG( "CMSRPMessageHandler::SendMessageL exit" )
 
   507     }
 
   560     }
 
   508 
   561 
   509 
   562 TBool CMSRPMessageHandler::IsOwnerOfResponse( MMSRPIncomingMessage& aIncomingMessage )
 
   510 void CMSRPMessageHandler::SendFileL(MMSRPConnection& aConnection)
 
   563     {
 
   511     {
 
   564     MSRPLOG2( "CMSRPMessageHandler::IsOwnerOfResponse enter =%d", this )
 
   512     MSRPLOG( "CMSRPMessageHandler::SendFileL enter" ) 
   565     for ( TInt i = 0; i < iSentChunks.Count(); i++ )
 
   513     /* Flags  */
 
   566         {
 
   514     isFile = ETrue;    
   567         if( aIncomingMessage.TransactionId() == *iSentChunks[ i ] )
 
   515     iProgress = iMessage->GetNotifyProgress();
 
   568             {
 
   516     
   569             MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse enter, yes" )
 
   517     User::LeaveIfError(iFs.Connect());
 
   570             iResponseNeeded = EFalse;
 
   518     User::LeaveIfError(iFile.Open(iFs, iMessage->GetFileName(), EFileShareReadersOrWriters)); 
   571             return ETrue;
 
   519     iFile.Size(iFileSize);
 
   572             }  
   520     iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);            
   573         }
 
   521     FillFileBufferL();
 
   574               
   522     iActiveMsgType = EMSRPMessage;
 
   575     MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse exit" )
 
   523     aConnection.SendL( *this );
 
   576     return EFalse;
 
   524     
   577     }
 
   525     MSRPLOG( "CMSRPMessageHandler::SendFileL exit" )     
       
   526     }
 
       
   527 
       
   528 
   578 
   529 TInt CMSRPMessageHandler::FillFileBufferL()
 
   579 TInt CMSRPMessageHandler::FillFileBufferL()
 
   530     {    
   580     {    
   531     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL enter" )
 
   581     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL enter" )
 
   532     iStartPosInBuffer = 0;
 
   582     iStartPosInBuffer = 0;
 
   538     MSRPLOG2( "CMSRPMessageHandler::FillFileBufferL File Buffer Length %d", iFileBuffer->Length());
 
   588     MSRPLOG2( "CMSRPMessageHandler::FillFileBufferL File Buffer Length %d", iFileBuffer->Length());
 
   539     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL exit" )     
   589     MSRPLOG( "CMSRPMessageHandler::FillFileBufferL exit" )     
   540 	return iFileBuffer->Length();
 
   590 	return iFileBuffer->Length();
 
   541     }
 
   591     }
 
   542 
   592 
   543 
   593 void CMSRPMessageHandler::TerminateReceiving( 
   544 void CMSRPMessageHandler::ReceiveFileL( )
 
   594     MMSRPMessageObserver* aMessageObserver, 
   545     {
 
   595     MMSRPConnection& aConnection )
 
   546     MSRPLOG( "CMSRPMessageHandler::ReceiveFileL enter" )
 
   596     {
 
   547     isFile = ETrue;
 
   597     MSRPLOG( "CMSRPMessageHandler::SetFSTerminate" )
 
   548     iProgress = iMessage->GetNotifyProgress();
 
   598     iTerminateReceiving = ETrue;
 
   549     
   599 
   550     User::LeaveIfError(iFs.Connect());
 
   600     SendResponseL( aMessageObserver, aConnection, EStopSending );
 
   551     User::LeaveIfError(iFile.Replace(iFs,iMessage->GetFileName(),EFileWrite));
 
   601     }
 
   552     iFileSize = iMessage->GetFileSize();
 
   602 
   553     iFileBuffer = HBufC8::NewL(KMaxChunkReadSize);
 
   603 void CMSRPMessageHandler::TerminateSending()
 
   554     
   604     {
 
   555     MSRPLOG( "CMSRPMessageHandler::ReceiveFileL exit" )
 
   605     MSRPLOG( "CMSRPMessageHandler::SetFSTerminate" )
 
   556     }
 
   606     iTerminateSending = ETrue;
 
   557 
   607     }
 
   558 
   608 
   559 void CMSRPMessageHandler::WritetoFileL(CMSRPMessageHandler *incomingMsgHandler )
 
   609 TBool CMSRPMessageHandler::IsTransmissionTerminated( )
 
   560     {
 
   610     {
 
   561     MSRPLOG( "CMSRPMessageHandler::WriteToFile enter" )
 
   611     MSRPLOG3("-> CMSRPMessageHandler::IsTransmissionTerminated, %d and %d", iTerminateReceiving, iTerminateSending )
 
   562     CMSRPMessage* inFileChunk = incomingMsgHandler->GetIncomingMessage();
 
   612     if ( iTerminateReceiving || iTerminateSending )
 
   563     HBufC8* messageContent = NULL;
 
   613         {
 
   564     if(inFileChunk->IsContent())
 
   614         return ETrue;
 
   565         {
 
   615         }
 
   566         messageContent = HBufC8::NewL(inFileChunk->Content().Length());
 
   616         
   567         *messageContent = inFileChunk->Content();        
   617     return EFalse;
 
   568         WriteChunkToFileL(*messageContent,incomingMsgHandler->TransactionId());
 
   618     }
 
   569        
   619 
   570         if (!incomingMsgHandler->IfResponseReqL())
 
   620 TBool CMSRPMessageHandler::IsReportNeeded( )
 
   571             ReceiveFileStateL(messageContent->Length());
 
   621     {
 
   572         }
 
   622     if( iMessage->SuccessReportHeader() )
 
   573     delete messageContent;
 
   623         {
 
   574     MSRPLOG( "CMSRPMessageHandler::WriteToFile exit" )          
   624         HBufC8* successHeaderValue = iMessage->SuccessReportHeader()->ToTextValueLC();
 
   575     }               
   625         if( successHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() )
 
   576     
   626             {
 
   577     
   627             CleanupStack::PopAndDestroy( successHeaderValue );
 
   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;
 
   628             return ETrue;
 
   632             }
 
   629             }
 
   633         }  
   630         CleanupStack::PopAndDestroy( successHeaderValue );
 
   634               
   631         }
 
   635     MSRPLOG( "CMSRPMessageHandler::IsOwnerOfResponse exit" )
 
   632         
   636     return EFalse;
 
   633     return EFalse;
 
   637     }
 
   634     }
 
   638 
   635 
   639 
   636 TUint CMSRPMessageHandler::ConsumeResponseL( MMSRPIncomingMessage& aIncomingMessage )
 
   640 void CMSRPMessageHandler::ConsumeFileResponseL(MMSRPIncomingMessage& aIncomingMessage )
 
   637     {
 
   641     {
 
   638     MSRPLOG2( "CMSRPMessageHandler::ConsumeResponseL enter, this = %d", this )
 
   642     MSRPLOG( "CMSRPMessageHandler::ConsumeFileResponseL enter" )
 
   639    
       
   640     TUint responseCode( EUnknownCode );
 
   643     CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();
 
   641     CMSRPResponse* response = aIncomingMessage.GetIncomingResponse();
 
   644     TUint statusCode = response->StatusCode();
 
   642     if ( response )
 
   645     
   643         {
 
   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();
 
   644         RStringF statusString = response->ReasonPhrase();
 
   729         iResponse = new (ELeave) CMSRPResponse( statusCode, statusString );
 
   645         responseCode = response->StatusCode();
 
       
   646         delete iResponse;
 
       
   647         iResponse = NULL;
 
       
   648         iResponse = new (ELeave) CMSRPResponse( responseCode, statusString );
 
   730         HBufC8* toPathValue = response->ToPathHeader()->ToTextValueLC();
 
   649         HBufC8* toPathValue = response->ToPathHeader()->ToTextValueLC();
 
   731         HBufC8* fromPathValue = response->FromPathHeader()->ToTextValueLC();
 
   650         HBufC8* fromPathValue = response->FromPathHeader()->ToTextValueLC();
 
   732         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( toPathValue->Des() ) );
 
   651         iResponse->SetToPathHeader( CMSRPToPathHeader::DecodeL( toPathValue->Des() ) );
 
   733         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( fromPathValue->Des() ) );
 
   652         iResponse->SetFromPathHeader( CMSRPFromPathHeader::DecodeL( fromPathValue->Des() ) );
 
   734         CleanupStack::PopAndDestroy(fromPathValue);
 
   653         CleanupStack::PopAndDestroy(fromPathValue);
 
   735         CleanupStack::PopAndDestroy(toPathValue);
 
   654         CleanupStack::PopAndDestroy(toPathValue);
 
       
   655         }
 
       
   656 
       
   657     // removing the transaction id
 
       
   658     for ( TInt i = 0; i < iSentChunks.Count(); i++ )
 
       
   659         {
 
       
   660         if( aIncomingMessage.TransactionId() == *iSentChunks[ i ] )
 
       
   661             {
 
       
   662             delete iSentChunks[ i ];
 
       
   663             iSentChunks.Remove( i );
 
       
   664             }  
       
   665         }
 
       
   666 
       
   667     if ( iState == EWaitingForResponse )
 
       
   668         {
 
   736         iState = EMessageDone;
 
   669         iState = EMessageDone;
 
   737         ret = ETrue;
 
   670         }
 
   738         }
 
   671        
   739     
   672     MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL exit" )
 
       
   673     return responseCode;
 
       
   674     }
 
       
   675 
       
   676 
       
   677 TBool CMSRPMessageHandler::IsMessageComplete()
 
       
   678     {
 
       
   679     MSRPLOG2( "CMSRPMessageHandler::IsMessageComplete enter= %d", this )
 
       
   680     MSRPLOG2( "CMSRPMessageHandler::IsMessageComplete enter= %d", iMessageEnding )
 
       
   681     MSRPLOG2( "CMSRPMessageHandler::IsMessageComplete enter= %d", iState )
 
       
   682     if ( iMessageEnding != EMessageEnd && iMessageEnding != EMessageTerminated )
 
       
   683         {
 
       
   684         return EFalse;
 
       
   685         }
 
       
   686     else if( iState == EMessageDone || iState == ETerminated )
 
       
   687         {
 
       
   688         return ETrue;
 
       
   689         }
 
       
   690     else
 
       
   691         {
 
       
   692         return EFalse;
 
       
   693         }
 
       
   694     }
 
       
   695 
       
   696 
       
   697 TUint CMSRPMessageHandler::GetSendResultL( HBufC8* &aMessageId )
 
       
   698     {
 
       
   699     MSRPLOG( "CMSRPMessageHandler::GetSendResult enter" )
 
       
   700     TUint aErrorCode( EUnknownCode );
 
       
   701     aMessageId = iMessage->MessageIdHeader()->ToTextValueLC();
 
       
   702     CleanupStack::Pop(aMessageId);
 
       
   703     if(iResponse)
 
       
   704         {
 
       
   705         aErrorCode = iResponse->StatusCode();
 
       
   706         }
 
       
   707         
       
   708     return aErrorCode;
 
       
   709     }
 
       
   710 
       
   711 // -----------------------------------------------------------------------------
 
       
   712 // CMSRPMessageHandler::IsFailureHeaderPartial
 
       
   713 // -----------------------------------------------------------------------------
 
       
   714 //
 
       
   715 TBool CMSRPMessageHandler::IsFailureHeaderPartial()
 
       
   716     {
 
   740     if( iMessage->FailureReportHeader() )
 
   717     if( iMessage->FailureReportHeader() )
 
   741         {
 
   718         {
 
   742         CleanupStack::PopAndDestroy(); // FR header value from above
 
   719         HBufC8* frHeaderValue = iMessage->FailureReportHeader()->ToTextValueLC();
 
   743         }
 
   720         if( frHeaderValue->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC() ) 
   744          
   721             {
 
   745     MSRPLOG( "CMSRPMessageHandler::ConsumeResponseL exit" )
 
   722             CleanupStack::PopAndDestroy(frHeaderValue);
 
   746     return ret;
 
   723             return ETrue;
 
   747     }
 
   724             }
 
   748 
   725         CleanupStack::PopAndDestroy(frHeaderValue);
 
   749 
   726         }
 
   750 TBool CMSRPMessageHandler::IsMessageComplete()
 
   727         
   751     {
 
   728     return EFalse;
 
   752     MSRPLOG( "CMSRPMessageHandler::IsMessageComplete enter" )
 
   729     }
 
   753     if( iState == EMessageDone )
 
   730 
   754         return ETrue;
 
   731 const TDesC8& CMSRPMessageHandler::GetSendBufferL( 
   755     else
 
   732     MMSRPWriterObserver::TWriteStatus& aStatus, 
   756         return EFalse;
 
   733     TBool aInterrupt )
 
   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     {
 
   734     {
 
   802     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL enter" )
 
   735     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL enter" )
 
   803     iInterrupt = aInterrupt;
 
   736     iInterrupt = aInterrupt;
 
   804     iWriteDone = EFalse;
 
   737     iWriteDone = EFalse;
 
   805     iBuffer.Zero();
 
   738     iBuffer.Zero();
 
   837             {
 
   770             {
 
   838              User::LeaveIfError(KErrArgument);
 
   771              User::LeaveIfError(KErrArgument);
 
   839             }
 
   772             }
 
   840         }
 
   773         }
 
   841     
   774     
   842     aData.Set(iBuffer);        
   775     aStatus = EMsrpSocketWrite;
 
   843     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL exit" )
 
   776     MSRPLOG( "CMSRPMessageHandler::GetSendBufferL exit" )
 
   844     return EMsrpSocketWrite;
 
   777     return iBuffer;
 
   845     }
 
   778     }
 
   846 
   779 
   847 
   780 
   848 MMSRPWriterObserver::TMsgStatus CMSRPMessageHandler::WriteDoneL( TInt aStatus )
 
   781 MMSRPWriterObserver::TMsgStatus CMSRPMessageHandler::WriteDoneL( TInt aStatus )
 
   849     {
 
   782     {
 
   850     MSRPLOG( "CMSRPMessageHandler::WriteDoneL enter" )
 
   783     MSRPLOG( "CMSRPMessageHandler::WriteDoneL enter" )
 
       
   784     MSRPLOG2( "CMSRPMessageHandler::WriteDoneL state = %d", iState )
 
       
   785     MSRPLOG2( "CMSRPMessageHandler::WriteDoneL activestate = %d", iActiveMsgType )
 
   851     MMSRPWriterObserver::TMsgStatus retStatus = EUndefined;
 
   786     MMSRPWriterObserver::TMsgStatus retStatus = EUndefined;
 
   852 
   787 
   853     if( !aStatus )
 
   788     if( !aStatus )
 
   854         {
 
   789         {
 
   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 )
 
   790         if( iState == EMessageSent )
 
   863             {
 
   791             {
 
   864             switch( iActiveMsgType )
 
   792             switch( iActiveMsgType )
 
   865                 {
 
   793                 {
 
   866                 case EMSRPMessage:
 
   794                 case EMSRPMessage:
 
   871                         }
 
   799                         }
 
   872                     else
 
   800                     else
 
   873                         {
 
   801                         {
 
   874                         iState = EMessageDone;
 
   802                         iState = EMessageDone;
 
   875                         }  
   803                         }  
   876                     iMSRPMessageObserver->MessageSendCompleteL();
 
   804                     iMSRPMessageObserver->MessageSendProgressL( this );   
       
   805                     iMSRPMessageObserver->MessageSendCompleteL( this );
 
       
   806                     retStatus = MMSRPWriterObserver::EComplete;
 
   877                     break;                    
   807                     break;                    
   878                     }
 
   808                     }
 
   879                 case EMSRPResponse:
 
   809                 case EMSRPResponse:
 
   880                     {
 
   810                     {
 
   881                     iState = EMessageDone;
 
   811                     if( iTerminateReceiving )
 
       
   812                         {
 
       
   813                         iState = ETerminated;
 
       
   814                         iMessageEnding = EMessageTerminated;
 
       
   815                         }
 
       
   816                     else
 
       
   817                         {
 
       
   818                         iState = EMessageDone;
 
       
   819                         }
 
       
   820                     iActiveMsgType = EMSRPNotDefined;
 
   882                     iMSRPMessageObserver->MessageResponseSendCompleteL(*this);
 
   821                     iMSRPMessageObserver->MessageResponseSendCompleteL(*this);
 
       
   822                     if ( IsReportNeeded() )
 
       
   823                         {
 
       
   824                         retStatus = MMSRPWriterObserver::ESendingReport;
 
       
   825                         }
 
       
   826                     else
 
       
   827                         {
 
       
   828                         retStatus = MMSRPWriterObserver::EComplete;
 
       
   829                         }
 
   883                     break;
 
   830                     break;
 
   884                     }
 
   831                     }
 
   885                 }
 
   832                 case EMSRPReport:
 
   886             //iActiveMsgType = EMSRPNotDefined;
 
   833                     {
 
   887             retStatus = MMSRPWriterObserver::EComplete;
 
   834                     iMessageEnding = EMessageEnd;
 
       
   835                     iState = EMessageDone;
 
       
   836                     iMSRPMessageObserver->MessageReportSendCompleteL( *this );
 
       
   837                     retStatus = MMSRPWriterObserver::EComplete;
 
       
   838                     break;
 
       
   839                     }
 
       
   840                 }
 
   888             }        
   841             }        
   889         else if( iState ==  EInProgress )
 
   842         else if( iState ==  EInProgress )
 
   890             {
 
   843             {
 
   891             retStatus = MMSRPWriterObserver::EPending;
 
   844             iMSRPMessageObserver->MessageSendProgressL( this ); 
   892             }            
   845             if ( iMessageEnding == EMessageNotDefined )
 
   893         else if(iState == EChunkSent)
 
   846                 {
 
   894             {
 
   847                 retStatus = MMSRPWriterObserver::EPending;
 
   895             retStatus = MMSRPWriterObserver::EInterrupted;
 
   848                 }
 
   896             iState = EIdle;
 
   849             else
 
   897             }        
   850                 {
 
       
   851                 iState = EIdle;
 
       
   852                 retStatus = MMSRPWriterObserver::EWaitingForResponse;
 
       
   853                 }
 
       
   854             }
 
       
   855         else if( iState == ETerminated )
 
       
   856             {
 
       
   857             if( iResponseNeeded )
 
       
   858                 {
 
       
   859                 iState = EWaitingForResponse;
 
       
   860                 }
 
       
   861                                         
       
   862             iMSRPMessageObserver->MessageCancelledL();
 
       
   863             retStatus = MMSRPWriterObserver::EComplete;
 
       
   864             }
 
   898         else
 
   865         else
 
   899            {
 
   866            {
 
   900            iMSRPMessageObserver->WriterError();
 
   867            iMSRPMessageObserver->WriterError();
 
   901            }
 
   868            }
 
   902         }
 
   869         }
 
   903     MSRPLOG( "CMSRPMessageHandler::WriteDone exit" )
 
   870 
   904     return retStatus;
 
   871     return retStatus;
 
   905     }
 
   872     }
 
   906 
   873 
   907 
   874 
   908 void CMSRPMessageHandler::CreateByteRangeHeaderL()
 
   875 void CMSRPMessageHandler::CreateByteRangeHeaderL()
 
   911     CMSRPByteRangeHeader* byteRange = NULL;
 
   878     CMSRPByteRangeHeader* byteRange = NULL;
 
   912        
   879        
   913     if ( iMessage->IsFile())
 
   880     if ( iMessage->IsFile())
 
   914         {                
   881         {                
   915         byteRange = CMSRPByteRangeHeader::NewL( iBufPosInFile+iStartPosInBuffer+1,KUnknownRange,iFileSize);
 
   882         byteRange = CMSRPByteRangeHeader::NewL( iBufPosInFile+iStartPosInBuffer+1,KUnknownRange,iFileSize);
 
   916       
       
   917         CleanupStack::PushL(byteRange);
 
       
   918         iMessage->SetByteRangeHeader( byteRange );
 
       
   919         CleanupStack::Pop(byteRange);
 
       
   920         }
 
   883         }
 
   921     else
 
   884     else
 
   922         {
 
   885         {
 
   923         if( !iMessage->ByteRangeHeader() )
 
   886         if ( iMessage->IsContent() )
 
   924             {
 
   887              {
 
   925              if ( iMessage->IsContent() )
 
   888              byteRange = CMSRPByteRangeHeader::NewL( 1,
 
   926                  {
 
   889              iMessage->Content().Length(), iMessage->Content().Length() );
 
   927                  byteRange = CMSRPByteRangeHeader::NewL( 1,
 
   890              }
 
   928                  iMessage->Content().Length(), iMessage->Content().Length() );
 
   891         else
 
   929                  CleanupStack::PushL(byteRange);
 
   892              {
 
   930                  }
 
   893              byteRange = CMSRPByteRangeHeader::NewL( 1, 0, 0 );
 
   931              else
 
   894              }
 
   932                  {
 
   895         }
 
   933                  byteRange = CMSRPByteRangeHeader::NewL( 1, 0, 0 );
 
   896     iMessage->SetByteRangeHeader( byteRange );
 
   934                  CleanupStack::PushL(byteRange);
 
       
   935                  }
 
       
   936             iMessage->SetByteRangeHeader( byteRange );
 
       
   937             CleanupStack::Pop(byteRange);
 
       
   938             }
 
       
   939         }
 
       
   940     MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL exit" )
 
   897     MSRPLOG( "CMSRPMessageHandler::CreateByteRangeHeaderL exit" )
 
   941     }
 
   898     }
 
   942 
   899 
   943 
   900 
   944 void CMSRPMessageHandler::CreateTransactionId()
 
   901 void CMSRPMessageHandler::CreateTransactionIdL()
 
   945     {
 
   902     {
 
   946     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId enter" )
 
   903     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId enter" )
 
   947     
   904     
   948     TTime now;
 
   905     TTime now;
 
   949     now.HomeTime();
 
   906     now.HomeTime();
 
   950     TInt64 seed = now.Int64();
 
   907     TInt64 seed = now.Int64();
 
   951     TInt random = Math::Rand( seed );
 
   908     TInt random = Math::Rand( seed );
 
   952     iTransactionId.NumUC( random );
 
   909     HBufC8* transactionId = HBufC8::NewL( KMaxLengthOfTransactionIdString );
 
       
   910     TPtr8 temp( transactionId->Des() );
 
       
   911     temp.NumUC( random );
 
       
   912     
       
   913     if ( iActiveMsgType != EMSRPReport )
 
       
   914         {
 
       
   915         // let's make sure the message content does not include the end line
 
       
   916         // otherwise we need to regenerate the random number
 
       
   917         TBuf8< KMaxLengthOfMessageEndString > endLine;
 
       
   918         endLine.Append( KAsterisk );
 
       
   919         endLine.Append( KDashLine );
 
       
   920         endLine.Append( temp );
 
       
   921         endLine.Append( KAsterisk );
 
       
   922         
       
   923         if ( iMessage->IsFile() )
 
       
   924             {
 
       
   925             // must first load the right chunk to memory temporarily
 
       
   926             RFile file;
 
       
   927             CleanupClosePushL( file );
 
       
   928             User::LeaveIfError(
 
       
   929                 file.Open( iFs, iMessage->GetFileName(), EFileShareReadersOrWriters ) );
 
       
   930         
       
   931             // Check that the file does not contain the generated ID
 
       
   932             TInt readPosition( 0 );
 
       
   933             HBufC8* tempFileBuffer = HBufC8::NewLC( KMaxChunkReadSize );
 
       
   934             TPtr8 fileBuffer( tempFileBuffer->Des() );
 
       
   935             User::LeaveIfError(
 
       
   936                 file.Read( readPosition, fileBuffer, KMaxChunkReadSize ) );
 
       
   937             while ( fileBuffer.Length() )
 
       
   938                 {
 
       
   939                 if ( fileBuffer.Match( endLine ) != KErrNotFound )
 
       
   940                     {
 
       
   941                     // found
 
       
   942                     random = Math::Rand( seed );
 
       
   943                     temp.NumUC( random );
 
       
   944                     endLine.Zero();
 
       
   945                     endLine.Append( KAsterisk );
 
       
   946                     endLine.Append( KDashLine );
 
       
   947                     endLine.Append( temp );
 
       
   948                     endLine.Append( KAsterisk );
 
       
   949                     readPosition = 0;
 
       
   950                     }
 
       
   951                 else
 
       
   952                     {
 
       
   953                     readPosition += ( KMaxChunkReadSize - KMaxLengthOfMessageEndString );
 
       
   954                     }
 
       
   955                 User::LeaveIfError(
 
       
   956                     file.Read( readPosition, fileBuffer, KMaxChunkReadSize ) );
 
       
   957                 }
 
       
   958             CleanupStack::PopAndDestroy( tempFileBuffer );
 
       
   959             CleanupStack::PopAndDestroy( ); // file
 
       
   960             }
 
       
   961         else
 
       
   962             {
 
       
   963             // content
 
       
   964             while ( iMessage->Content().Match( temp ) != KErrNotFound )
 
       
   965                 {
 
       
   966                 // found
 
       
   967                 random = Math::Rand( seed );
 
       
   968                 temp.NumUC( random );
 
       
   969                 endLine.Zero();
 
       
   970                 endLine.Append( KAsterisk );
 
       
   971                 endLine.Append( KDashLine );
 
       
   972                 endLine.Append( temp );
 
       
   973                 endLine.Append( KAsterisk );
 
       
   974                 }
 
       
   975             }
 
       
   976         }
 
       
   977     iSentChunks.Append( transactionId );
 
   953     
   978     
   954     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId exit" )
 
   979     MSRPLOG( "CMSRPMessageHandler::CreateTransactionId exit" )
 
   955     }
 
   980     }
 
   956 
   981 
   957 
   982 
   958 void CMSRPMessageHandler::WriteInitialLineToBufferL()
 
   983 void CMSRPMessageHandler::WriteInitialLineToBufferL()
 
   959     {
 
   984     {
 
   960     MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL enter" )
 
   985     MSRPLOG( "CMSRPMessageHandler::WriteInitialLineToBufferL enter" )
 
   961     
   986     
       
   987     if( iActiveMsgType == EMSRPMessage )
 
       
   988         {
 
       
   989         iMessageEnding = EMessageNotDefined;
 
       
   990         }
 
   962     iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::EMSRP ).DesC() );
 
   991     iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::EMSRP ).DesC() );
 
   963 
   992 
   964     iBuffer.Append( KSpaceChar );
 
   993     iBuffer.Append( KSpaceChar );
 
   965     
   994     
   966     if (! (iActiveMsgType == EMSRPResponse) )
 
   995     if (! (iActiveMsgType == EMSRPResponse) )
 
   967          {
 
   996          {
 
   968          CreateTransactionId();
 
   997          CreateTransactionIdL();
 
   969          }
 
   998          }
 
   970    
   999    
   971     iBuffer.Append( iTransactionId );
 
  1000     iBuffer.Append( *iSentChunks[ iSentChunks.Count() -1 ] );
 
   972 
  1001 
   973     iBuffer.Append( KSpaceChar );
 
  1002     iBuffer.Append( KSpaceChar );
 
   974     
  1003     
   975     if ( iActiveMsgType == EMSRPMessage )
 
  1004     if ( iActiveMsgType == EMSRPMessage )
 
   976         {
 
  1005         {
 
   982         statusCode.NumUC( iResponse->StatusCode() );
 
  1011         statusCode.NumUC( iResponse->StatusCode() );
 
   983         iBuffer.Append( statusCode );
 
  1012         iBuffer.Append( statusCode );
 
   984         iBuffer.Append( KSpaceChar );
 
  1013         iBuffer.Append( KSpaceChar );
 
   985         iBuffer.Append( iResponse->ReasonPhrase().DesC() );
 
  1014         iBuffer.Append( iResponse->ReasonPhrase().DesC() );
 
   986         }
 
  1015         }
 
       
  1016     else if ( iActiveMsgType == EMSRPReport )
 
       
  1017         {
 
       
  1018         iBuffer.Append( MSRPStrings::StringF( MSRPStrConsts::EReport ).DesC() );
 
       
  1019         }
 
   987     else
 
  1020     else
 
   988         {
 
  1021         {
 
   989         User::Leave( KErrArgument );
 
  1022         User::Leave( KErrArgument );
 
   990         }
 
  1023         }
 
   991 
  1024 
  1005         messageBase = iMessage;
 
  1038         messageBase = iMessage;
 
  1006         }
 
  1039         }
 
  1007     else if ( iActiveMsgType == EMSRPResponse )
 
  1040     else if ( iActiveMsgType == EMSRPResponse )
 
  1008         {
 
  1041         {
 
  1009         messageBase = iResponse;
 
  1042         messageBase = iResponse;
 
       
  1043         }
 
       
  1044     else if ( iActiveMsgType == EMSRPReport )
 
       
  1045         {
 
       
  1046         messageBase = iReport;
 
  1010         }
 
  1047         }
 
  1011     else
 
  1048     else
 
  1012         {
 
  1049         {
 
  1013         User::Leave( KErrArgument );
 
  1050         User::Leave( KErrArgument );
 
  1014         }
 
  1051         }
 
  1043             }
 
  1080             }
 
  1044 
  1081 
  1045         if ( messageBase->FailureReportHeader() )
 
  1082         if ( messageBase->FailureReportHeader() )
 
  1046             {
 
  1083             {
 
  1047             HBufC8* valueString = messageBase->FailureReportHeader()->ToTextValueLC();
 
  1084             HBufC8* valueString = messageBase->FailureReportHeader()->ToTextValueLC();
 
  1048             if ( valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() ||
 
  1085             if ( valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EYes ).DesC() )
 
  1049                 valueString->Des() == MSRPStrings::StringF( MSRPStrConsts::EPartial ).DesC() )
 
       
  1050                 {
 
  1086                 {
 
  1051                 iResponseNeeded = ETrue;
 
  1087                 iResponseNeeded = ETrue;
 
  1052                 }
 
  1088                 }
 
  1053             CleanupStack::PopAndDestroy(valueString);
 
  1089             CleanupStack::PopAndDestroy(valueString);
 
  1054 
  1090 
  1066         {
 
  1102         {
 
  1067         iBuffer.Append( messageBase->ByteRangeHeader()->ToTextLC()->Des() );
 
  1103         iBuffer.Append( messageBase->ByteRangeHeader()->ToTextLC()->Des() );
 
  1068         CleanupStack::PopAndDestroy(); // above 
  1104         CleanupStack::PopAndDestroy(); // above 
  1069         iBuffer.Append( KCRAndLF );
 
  1105         iBuffer.Append( KCRAndLF );
 
  1070         }
 
  1106         }
 
  1071     
  1107 
       
  1108     if( iActiveMsgType == EMSRPReport )
 
       
  1109         {
 
       
  1110         iBuffer.Append( messageBase->StatusHeader()->ToTextLC()->Des() );
 
       
  1111         CleanupStack::PopAndDestroy(); // above 
       
  1112         iBuffer.Append( KCRAndLF );
 
       
  1113         }
 
       
  1114         
  1072     if( iActiveMsgType == EMSRPMessage )
 
  1115     if( iActiveMsgType == EMSRPMessage )
 
  1073         {
 
  1116         {
 
  1074         if ( messageBase->ContentTypeHeader() )
 
  1117         if ( messageBase->ContentTypeHeader() )
 
  1075             {
 
  1118             {
 
  1076             iBuffer.Append( messageBase->ContentTypeHeader()->ToTextLC()->Des() );
 
  1119             iBuffer.Append( messageBase->ContentTypeHeader()->ToTextLC()->Des() );
 
  1090 
  1133 
  1091 
  1134 
  1092 void CMSRPMessageHandler::WriteFileContentToBufferL()
 
  1135 void CMSRPMessageHandler::WriteFileContentToBufferL()
 
  1093     {
 
  1136     {
 
  1094     MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer enter" )
 
  1137     MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer enter" )
 
  1095     TInt endlineSize = iTransactionId.Length() + KEndlineConstLength;
 
  1138     TInt endlineSize = iSentChunks[ iSentChunks.Count() -1 ]->Length() + KEndlineConstLength;
 
  1096     TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length() - endlineSize - KCRAndLF().Length();
 
  1139     TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length() - endlineSize - KCRAndLF().Length();
 
  1097     TInt chunkLength = iFileBuffer->Length() - iEndPosInBuffer;
 
  1140     TInt chunkLength = iFileBuffer->Length() - iEndPosInBuffer;
 
  1098     
  1141     
  1099     /*if(remBufferSize<0) TODO*/
 
       
  1100     if(chunkLength > remBufferSize)
 
  1142     if(chunkLength > remBufferSize)
 
  1101         {
 
  1143         {
 
  1102         iFileBytesSent = remBufferSize;
 
  1144         iFileBytesSent = remBufferSize;
 
  1103         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
 
  1145         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
 
  1104         iEndPosInBuffer += iFileBytesSent;
 
  1146         iEndPosInBuffer += iFileBytesSent;
 
  1105         if(iInterrupt)
 
  1147         
  1106             {
 
  1148         if( iTerminateSending )
 
       
  1149             {
 
       
  1150             iBuffer.Append(KCRAndLF());
 
       
  1151             WriteEndLineToBuffer( EMessageTerminated );
 
       
  1152             iStartPosInBuffer = iEndPosInBuffer;
 
       
  1153             iState = ETerminated;
 
       
  1154             }
 
       
  1155         else if(iInterrupt)
 
       
  1156             {
 
       
  1157             iBuffer.Append(KCRAndLF());
 
  1107             WriteEndLineToBuffer(EMessageContinues);
 
  1158             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;
 
  1159             iStartPosInBuffer = iEndPosInBuffer;
 
  1116             iState = EChunkSent;
 
  1160             }        
  1117             }
 
       
  1118        /* else
 
  1161        /* else
 
  1119             {
 
  1162             {
 
  1120             //msg state remains InProgress (in write done return pending)
 
  1163             //msg state remains InProgress (in write done return pending)
 
  1121             }*/
 
  1164             }*/
 
  1122         }
 
  1165         }
 
       
  1166     else //bytes completed in current file buffer
 
       
  1167         {
 
       
  1168         iFileBytesSent = chunkLength;
 
       
  1169         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
 
       
  1170         iEndPosInBuffer += iFileBytesSent;
 
       
  1171         
       
  1172         if ( FillFileBufferL() == 0 )
 
       
  1173             {
 
       
  1174             iBuffer.Append( KCRAndLF( ) );
 
       
  1175             WriteEndLineToBuffer( EMessageEnd );
 
       
  1176             iState = EMessageSent;
 
       
  1177             }
 
       
  1178         
       
  1179         if( iTerminateSending && iState != EMessageSent )
 
       
  1180             {
 
       
  1181             iBuffer.Append( KCRAndLF( ) );
 
       
  1182             WriteEndLineToBuffer( EMessageTerminated );
 
       
  1183             iState = ETerminated;
 
       
  1184             }
 
       
  1185         }
 
       
  1186 #if 0
 
       
  1187 /* This is an alternative piece of code which writes the message in chunks. 
       
  1188  * The size of chunk is determined by the size of the iBuffer
 
       
  1189  */
 
  1123     else //bytes completed in current file buffer
 
  1190     else //bytes completed in current file buffer
 
  1124         {
 
  1191         {
 
  1125         iFileBytesSent = chunkLength;
 
  1192         iFileBytesSent = chunkLength;
 
  1126         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
 
  1193         iBuffer.Append(iFileBuffer->Mid(iEndPosInBuffer, iFileBytesSent));
 
  1127         iEndPosInBuffer += iFileBytesSent;
 
  1194         iEndPosInBuffer += iFileBytesSent;
 
  1128         iBuffer.Append(KCRAndLF());
 
  1195         iBuffer.Append(KCRAndLF());
 
  1129         
  1196         
  1130         //add chunk entry
 
  1197         if(iTerminateFS)
 
  1131         CMSRPMessageChunkState* iChunk = CMSRPMessageChunkState::NewL( ); 
  1198             {
 
  1132         iChunk->SetStartPos(iBufPosInFile+iStartPosInBuffer);           
  1199             WriteEndLineToBuffer(EMessageTerminated);
 
  1133         iChunk->SetEndPos(iBufPosInFile+iEndPosInBuffer-1); 
  1200             iState = ETerminated;
 
  1134         iChunk->SetTransactionId(iTransactionId);
 
  1201             }
 
  1135         iChunkList.Append(iChunk);
 
  1202         else if(FillFileBufferL() > 0)
 
  1136         
       
  1137         if(FillFileBufferL() > 0)
 
       
  1138             {
 
  1203             {
 
  1139             //next file buffer has data
 
  1204             //next file buffer has data
 
  1140             WriteEndLineToBuffer(EMessageContinues);
 
  1205             WriteEndLineToBuffer(EMessageContinues);
 
  1141             iState = EChunkSent;        
       
  1142             }
 
  1206             }
 
  1143         else
 
  1207         else
 
  1144             {
 
  1208             {
 
  1145             WriteEndLineToBuffer(EMessageEnd);
 
  1209             WriteEndLineToBuffer(EMessageEnd);
 
  1146             iState = EMessageSent;
 
  1210             iState = EMessageSent;
 
  1147             }
 
  1211             }
 
  1148 
  1212         }
 
  1149         }
 
  1213 #endif
 
  1150     
  1214     
  1151     iWriteDone = ETrue;
 
  1215     iWriteDone = ETrue;
 
  1152     MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer exit" )
 
  1216     MSRPLOG( "CMSRPMessageHandler::WriteFileContentToBuffer exit" )
 
  1153     }
 
  1217     }
 
  1154 
  1218 
  1180 void CMSRPMessageHandler::WriteEndLineToBuffer(MMSRPMessageHandler::TMsrpMsgEndStatus aEndFlag)
 
  1244 void CMSRPMessageHandler::WriteEndLineToBuffer(MMSRPMessageHandler::TMsrpMsgEndStatus aEndFlag)
 
  1181     {
 
  1245     {
 
  1182     MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer enter" )
 
  1246     MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer enter" )
 
  1183         
  1247         
  1184     TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length();        
  1248     TInt remBufferSize = iBuffer.MaxLength() - iBuffer.Length();        
  1185     TInt endlineSize = iTransactionId.Length() + KEndlineConstLength;
 
  1249     TInt endlineSize = iSentChunks[ iSentChunks.Count() -1 ]->Length() + KEndlineConstLength;
 
  1186     
  1250     
  1187     if( endlineSize <= remBufferSize )
 
  1251     if( endlineSize <= remBufferSize )
 
  1188         {
 
  1252         {
 
  1189         iBuffer.Append( KDashLine );
 
  1253         iBuffer.Append( KDashLine );
 
  1190         iBuffer.Append( iTransactionId );
 
  1254         iBuffer.Append( *iSentChunks[ iSentChunks.Count() -1 ] );
 
  1191         
  1255         
  1192         if(iActiveMsgType == EMSRPResponse)
 
  1256         if(iActiveMsgType == EMSRPResponse)
 
  1193             {
 
  1257             {
 
  1194             iBuffer.Append( KMessageEndSign );
 
  1258             iBuffer.Append( KMessageEndSign );
 
  1195             iState = EMessageSent;
 
  1259             iState = EMessageSent;
 
  1196             }
 
  1260             }
 
  1197         else
 
  1261         else
 
  1198             {
 
  1262             {
 
  1199             if( aEndFlag )
 
  1263             if( aEndFlag == EMessageTerminated )
 
  1200                {
 
  1264                 {
 
  1201                iBuffer.Append( KMessageContinuesSign );
 
  1265                 MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer - Appending #" )    
  1202                }
 
  1266                 iBuffer.Append( KMessageTerminatedSign );
 
       
  1267                 iMessageEnding = EMessageTerminated;
 
       
  1268                 }
 
       
  1269             else if( aEndFlag == EMessageContinues )
 
       
  1270                 {
 
       
  1271                 MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer - Appending +" )
 
       
  1272                 iBuffer.Append( KMessageContinuesSign );
 
       
  1273                 iMessageEnding = EMessageContinues;
 
       
  1274                 }
 
  1203             else
 
  1275             else
 
  1204                {
 
  1276                 {
 
  1205                iBuffer.Append( KMessageEndSign );
 
  1277                 MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer - Appending $" )
 
  1206                iState = EMessageSent;
 
  1278                 iBuffer.Append( KMessageEndSign );
 
  1207                }
 
  1279                 iMessageEnding = EMessageEnd;
 
       
  1280                 iState = EMessageSent;
 
       
  1281                 }
 
  1208             }
 
  1282             }
 
  1209         iBuffer.Append( KCRAndLF );        
  1283         iBuffer.Append( KCRAndLF );        
  1210         }        
  1284         }
 
       
  1285         
  1211     iWriteDone = ETrue;
 
  1286     iWriteDone = ETrue;
 
  1212     MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer exit" )
 
  1287     MSRPLOG( "CMSRPMessageHandler::WriteEndLineToBuffer exit" )
 
  1213     }
 
  1288     }
 
  1214 
  1289 
  1215 
  1290 
  1250     RStringF statusString;
 
  1325     RStringF statusString;
 
  1251     CleanupClosePushL( statusString );
 
  1326     CleanupClosePushL( statusString );
 
  1252     
  1327     
  1253     switch( aStatusCode )
 
  1328     switch( aStatusCode )
 
  1254         {
 
  1329         {
 
  1255         case CMSRPResponse::EAllOk:
 
  1330         case EAllOk:
 
  1256             {
 
  1331             {
 
  1257             statusString = MSRPStrings::StringF( MSRPStrConsts::EAllOk );
 
  1332             statusString = MSRPStrings::StringF( MSRPStrConsts::EAllOk );
 
  1258             break;
 
  1333             break;
 
  1259             }
 
  1334             }
 
  1260         case CMSRPResponse::EUnintelligibleRequest:
 
  1335         case EUnintelligibleRequest:
 
  1261             {
 
  1336             {
 
  1262             statusString = MSRPStrings::StringF( MSRPStrConsts::EUnintelligibleRequest );
 
  1337             statusString = MSRPStrings::StringF( MSRPStrConsts::EUnintelligibleRequest );
 
  1263             break;
 
  1338             break;
 
  1264             }
 
  1339             }
 
  1265         case CMSRPResponse::EActionNotAllowed:
 
  1340         case EActionNotAllowed:
 
  1266             {
 
  1341             {
 
  1267             statusString = MSRPStrings::StringF( MSRPStrConsts::EActionNotAllowed );
 
  1342             statusString = MSRPStrings::StringF( MSRPStrConsts::EActionNotAllowed );
 
  1268             break;
 
  1343             break;
 
  1269             }
 
  1344             }
 
  1270         case CMSRPResponse::ETimeout:
 
  1345         case ETimeout:
 
  1271             {
 
  1346             {
 
  1272             statusString = MSRPStrings::StringF( MSRPStrConsts::ETimeout );
 
  1347             statusString = MSRPStrings::StringF( MSRPStrConsts::ETimeout );
 
  1273             break;
 
  1348             break;
 
  1274             }
 
  1349             }
 
  1275         case CMSRPResponse::EStopSending:
 
  1350         case EStopSending:
 
  1276             {
 
  1351             {
 
  1277             statusString = MSRPStrings::StringF( MSRPStrConsts::EStopSending );
 
  1352             statusString = MSRPStrings::StringF( MSRPStrConsts::EStopSending );
 
  1278             break;
 
  1353             break;
 
  1279             }
 
  1354             }
 
  1280         case CMSRPResponse::EMimeNotUnderstood:
 
  1355         case EMimeNotUnderstood:
 
  1281             {
 
  1356             {
 
  1282             statusString = MSRPStrings::StringF( MSRPStrConsts::EMimeNotUnderstood );
 
  1357             statusString = MSRPStrings::StringF( MSRPStrConsts::EMimeNotUnderstood );
 
  1283             break;
 
  1358             break;
 
  1284             }
 
  1359             }
 
  1285         case CMSRPResponse::EParameterOutOfBounds:
 
  1360         case EParameterOutOfBounds:
 
  1286             {
 
  1361             {
 
  1287             statusString = MSRPStrings::StringF( MSRPStrConsts::EParameterOutOfBounds );
 
  1362             statusString = MSRPStrings::StringF( MSRPStrConsts::EParameterOutOfBounds );
 
  1288             break;
 
  1363             break;
 
  1289             }
 
  1364             }
 
  1290         case CMSRPResponse::ESessionDoesNotExist:
 
  1365         case ESessionDoesNotExist:
 
  1291             {
 
  1366             {
 
  1292             statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionDoesNotExist );
 
  1367             statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionDoesNotExist );
 
  1293             break;
 
  1368             break;
 
  1294             }
 
  1369             }
 
  1295         case CMSRPResponse::EUnknownRequestMethod:
 
  1370         case EUnknownRequestMethod:
 
  1296             {
 
  1371             {
 
  1297             statusString = MSRPStrings::StringF( MSRPStrConsts::EUnknownRequestMethod );
 
  1372             statusString = MSRPStrings::StringF( MSRPStrConsts::EUnknownRequestMethod );
 
  1298             break;
 
  1373             break;
 
  1299             }
 
  1374             }
 
  1300         case CMSRPResponse::ESessionAlreadyBound:
 
  1375         case ESessionAlreadyBound:
 
  1301             {
 
  1376             {
 
  1302             statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionAlreadyBound );
 
  1377             statusString = MSRPStrings::StringF( MSRPStrConsts::ESessionAlreadyBound );
 
  1303             break;
 
  1378             break;
 
  1304             }
 
  1379             }
 
  1305         default:
 
  1380         default:
 
  1320         
  1395         
  1321     if( aMessageType == EMSRPMessage )
 
  1396     if( aMessageType == EMSRPMessage )
 
  1322         {
 
  1397         {
 
  1323         if(!aMessage->MessageIdHeader())
 
  1398         if(!aMessage->MessageIdHeader())
 
  1324             {
 
  1399             {
 
  1325             return CMSRPResponse::EUnintelligibleRequest;
 
  1400             return EUnintelligibleRequest;
 
  1326             }
 
  1401             }
 
  1327         CMSRPMessage* message = static_cast<CMSRPMessage*>(aMessage);
 
  1402         CMSRPMessage* message = static_cast<CMSRPMessage*>(aMessage);
 
  1328         if(message->IsContent() && !message->ContentTypeHeader())
 
  1403         if(message->IsContent() && !message->ContentTypeHeader())
 
  1329             {
 
  1404             {
 
  1330             return CMSRPResponse::EUnintelligibleRequest;
 
  1405             return EUnintelligibleRequest;
 
  1331             }
 
  1406             }
 
  1332         }
 
  1407         }
 
  1333     
  1408     
  1334     MSRPLOG( "CMSRPMessageHandler::CheckValidityOfMessage exit" )
 
  1409     MSRPLOG( "CMSRPMessageHandler::CheckValidityOfMessage exit" )
 
  1335     return CMSRPResponse::EAllOk;
 
  1410     return EAllOk;
 
  1336     }
 
  1411     }
 
  1337 
  1412 
       
  1413 // -----------------------------------------------------------------------------
 
       
  1414 // CMSRPMessageHandler::OpenTemporaryFileL
 
       
  1415 // -----------------------------------------------------------------------------
 
       
  1416 //
 
       
  1417 void CMSRPMessageHandler::OpenTemporaryFileL( const TDesC& aFilename )
 
       
  1418     {
 
       
  1419     MSRPLOG( "CMSRPMessageHandler::OpenTemporaryFileL enter" )
 
       
  1420 
       
  1421     iTempFile = new ( ELeave ) RFile();
 
       
  1422     // create temporary filename
 
       
  1423     iTempFile->Open( iFs, aFilename, EFileShareExclusive | EFileWrite );
 
       
  1424 
       
  1425     MSRPLOG2( "CMSRPMessageHandler::OpenTemporaryFileL exit, filename = %S", &iTempFileName )
 
       
  1426     }
 
       
  1427 
       
  1428 // -----------------------------------------------------------------------------
 
       
  1429 // CMSRPMessageHandler::CreateTemporaryFileL
 
       
  1430 // -----------------------------------------------------------------------------
 
       
  1431 //
 
       
  1432 void CMSRPMessageHandler::CreateTemporaryFileL( )
 
       
  1433     {
 
       
  1434     MSRPLOG( "CMSRPMessageHandler::CreateTemporaryFileL enter" )
 
       
  1435 
       
  1436     iTempFile = new ( ELeave ) RFile();
 
       
  1437     // create temporary filename
 
       
  1438     User::LeaveIfError( iTempFile->Temp(
 
       
  1439         iFs, KDefaultTempFilePath, iTempFileName, EFileShareExclusive | EFileWrite ) );
 
       
  1440     iMessage->SetFileName( iTempFileName );
 
       
  1441 
       
  1442     MSRPLOG2( "CMSRPMessageHandler::CreateTemporaryFileL exit, filename = %S", &iTempFileName )
 
       
  1443     }
 
       
  1444 
       
  1445 // -----------------------------------------------------------------------------
 
       
  1446 // CMSRPMessageHandler::WriteMessageToFileL
 
       
  1447 // -----------------------------------------------------------------------------
 
       
  1448 //
 
       
  1449 void CMSRPMessageHandler::WriteMessageToFileL( TDesC8& aBuffer )
 
       
  1450     {
 
       
  1451     MSRPLOG( "CMSRPSocketReader::WriteMessageToFileL enter" )
 
       
  1452 
       
  1453     if ( !iTempFileName.Length() )
 
       
  1454         {
 
       
  1455         CreateTemporaryFileL();
 
       
  1456         }
 
       
  1457     else
 
       
  1458         {
 
       
  1459         OpenTemporaryFileL( iTempFileName );
 
       
  1460         }
 
       
  1461 
       
  1462     MSRPLOG2( "CMSRPSocketReader::WriteMessageToFileL writing to file = %S", &iMessage->GetFileName() );
 
       
  1463 
       
  1464     TInt fileSize;
 
       
  1465     iTempFile->Size( fileSize );
 
       
  1466     if ( iMessage->ByteRangeHeader()->StartPosition() > fileSize )
 
       
  1467         {
 
       
  1468         iTempFile->SetSize(
 
       
  1469             iMessage->ByteRangeHeader()->StartPosition() );
 
       
  1470         }
 
       
  1471     iTempFile->Size( fileSize );
 
       
  1472 
       
  1473     iTempFile->Write(
 
       
  1474         iMessage->ByteRangeHeader()->StartPosition() - 1, aBuffer );
 
       
  1475     MSRPLOG2( "CMSRPSocketReader::WriteMessageToFileL writing to pos = %d", iMessage->ByteRangeHeader()->StartPosition() - 1 );
 
       
  1476     iTempFile->Size( iCurrentNumberOfBytes );
 
       
  1477     iTempFile->Close();
 
       
  1478     delete iTempFile;
 
       
  1479     iTempFile = NULL;
 
       
  1480                         
       
  1481     MSRPLOG( "CMSRPSocketReader::WriteMessageToFileL exit" )
 
       
  1482     }
 
       
  1483 
       
  1484 // -----------------------------------------------------------------------------
 
       
  1485 // CMSRPMessageHandler::AppendMessageToFileL
 
       
  1486 // -----------------------------------------------------------------------------
 
       
  1487 //
 
       
  1488 void CMSRPMessageHandler::AppendMessageToFileL( TDesC8& aBuffer )
 
       
  1489     {
 
       
  1490     MSRPLOG( "CMSRPSocketReader::AppendMessageToFileL enter" )
 
       
  1491     OpenTemporaryFileL( iMessage->GetFileName() );
 
       
  1492 
       
  1493     TInt filePos( 0 );
 
       
  1494     iTempFile->Seek( ESeekEnd, filePos );
 
       
  1495 
       
  1496 TInt fileSize;
 
       
  1497 iTempFile->Size( fileSize );
 
       
  1498 MSRPLOG2( "CMSRPSocketReader::AppendMessageToFileL writing to pos = %d", fileSize );
 
       
  1499 
       
  1500     iTempFile->Write( aBuffer );
 
       
  1501     iTempFile->Size( iCurrentNumberOfBytes );
 
       
  1502     iTempFile->Close();
 
       
  1503     delete iTempFile;
 
       
  1504     iTempFile = NULL;
 
       
  1505 
       
  1506     MSRPLOG( "CMSRPSocketReader::AppendMessageToFileL exit" )
 
       
  1507     }
 
       
  1508 
       
  1509 // -----------------------------------------------------------------------------
 
       
  1510 // CMSRPMessageHandler::MessageId
 
       
  1511 // -----------------------------------------------------------------------------
 
       
  1512 //
 
       
  1513 HBufC8* CMSRPMessageHandler::MessageIdLC( )
 
       
  1514     {
 
       
  1515     return iMessage->MessageIdHeader()->ToTextValueLC();
 
       
  1516     }
 
       
  1517 
       
  1518 // -----------------------------------------------------------------------------
 
       
  1519 // CMSRPMessageHandler::CurrentReceiveProgress
 
       
  1520 // -----------------------------------------------------------------------------
 
       
  1521 //
 
       
  1522 void CMSRPMessageHandler::CurrentReceiveProgress( TInt& aBytesTransferred, TInt& aTotalBytes )
 
       
  1523     {
 
       
  1524     aBytesTransferred = iCurrentNumberOfBytes;
 
       
  1525     aTotalBytes = iMessage->ByteRangeHeader()->TotalLength(); 
       
  1526     }
 
       
  1527 
       
  1528 // -----------------------------------------------------------------------------
 
       
  1529 // CMSRPMessageHandler::CurrentSendProgress
 
       
  1530 // -----------------------------------------------------------------------------
 
       
  1531 //
 
       
  1532 void CMSRPMessageHandler::CurrentSendProgress( TInt& aBytesTransferred, TInt& aTotalBytes )
 
       
  1533     {
 
       
  1534     if ( iBufPosInFile )
 
       
  1535         {
 
       
  1536         aBytesTransferred = iBufPosInFile;
 
       
  1537         aTotalBytes = iFileSize; 
       
  1538         }
 
       
  1539     else
 
       
  1540         {
 
       
  1541         aBytesTransferred = iMessage->Content().Length() - iContentPtr.Length();
 
       
  1542         aTotalBytes = iMessage->Content().Length(); 
       
  1543         }
 
       
  1544     }
 
       
  1545 
       
  1546 // -----------------------------------------------------------------------------
 
       
  1547 // CMSRPMessageHandler::CheckMessageChunk
 
       
  1548 // -----------------------------------------------------------------------------
 
       
  1549 //
 
       
  1550 TBool CMSRPMessageHandler::CheckMessageChunkL( CMSRPMessageHandler& aOtherMessage )
 
       
  1551     {
 
       
  1552     MSRPLOG( "-> CMSRPMessageHandler::CheckMessageChunk" )
 
       
  1553     HBufC8* ownToPath = iMessage->ToPathHeader()->ToTextValueLC(); 
       
  1554     HBufC8* ownMessageId = iMessage->MessageIdHeader()->ToTextValueLC();
 
       
  1555     HBufC8* otherToPath = aOtherMessage.GetIncomingMessage()->ToPathHeader()->ToTextValueLC();
 
       
  1556     HBufC8* otherMessageId = aOtherMessage.GetIncomingMessage()->MessageIdHeader()->ToTextValueLC();
 
       
  1557     
       
  1558     if ( *ownToPath == *otherToPath && *ownMessageId == *otherMessageId )
 
       
  1559         {
 
       
  1560         CleanupStack::PopAndDestroy( 4 ); // above texts
 
       
  1561         MSRPLOG( "CMSRPMessageHandler::CheckMessageChunk MATCH!" )
 
       
  1562         // there is already a message, this chunk belongs to a previous
 
       
  1563         // message 
       
  1564         if ( iMessage->ByteRangeHeader() )
 
       
  1565             {
 
       
  1566             CMSRPByteRangeHeader* byteR = CMSRPByteRangeHeader::NewL(
 
       
  1567                     iMessage->ByteRangeHeader()->StartPosition( ),
 
       
  1568                     iMessage->ByteRangeHeader()->EndPosition( ),
 
       
  1569                     iMessage->ByteRangeHeader()->TotalLength( ) );
 
       
  1570             aOtherMessage.GetIncomingMessage()->SetByteRangeHeader( byteR );
 
       
  1571             }
 
       
  1572         aOtherMessage.SetTransactionId( *iSentChunks[ iSentChunks.Count() -1 ] );
 
       
  1573         MSRPLOG( "CMSRPMessageHandler::CheckMessageChunk MATCH2!" )
 
       
  1574         return ETrue;
 
       
  1575         }
 
       
  1576         
       
  1577     CleanupStack::PopAndDestroy( 4 ); // above texts
 
       
  1578     MSRPLOG( "<- CMSRPMessageHandler::CheckMessageChunk" )
 
       
  1579     return EFalse;
 
       
  1580     }
 
       
  1581     
       
  1582 // -----------------------------------------------------------------------------
 
       
  1583 // CMSRPMessageHandler::CheckMessageChunk
 
       
  1584 // -----------------------------------------------------------------------------
 
       
  1585 //
 
       
  1586 void CMSRPMessageHandler::SetMessageObserver( MMSRPMessageObserver* aMessageObserver )
 
       
  1587     {
 
       
  1588     iMSRPMessageObserver = aMessageObserver;
 
       
  1589     }
 
       
  1590 
       
  1591 // -----------------------------------------------------------------------------
 
       
  1592 // CMSRPMessageHandler::IsSending
 
       
  1593 // -----------------------------------------------------------------------------
 
       
  1594 //
 
       
  1595 TBool CMSRPMessageHandler::IsSending( )
 
       
  1596     {
 
       
  1597     return isSending;
 
       
  1598     }
 
       
  1599 
       
  1600 // -----------------------------------------------------------------------------
 
       
  1601 // CMSRPMessageHandler::TemporaryFileName
 
       
  1602 // -----------------------------------------------------------------------------
 
       
  1603 //
 
       
  1604 TFileName& CMSRPMessageHandler::TemporaryFileName( )
 
       
  1605     {
 
       
  1606     return iTempFileName;
 
       
  1607     }
 
       
  1608 
       
  1609 // -----------------------------------------------------------------------------
 
       
  1610 // CMSRPMessageHandler::SetTemporaryFileName
 
       
  1611 // -----------------------------------------------------------------------------
 
       
  1612 //
 
       
  1613 void CMSRPMessageHandler::SetTemporaryFileName( TFileName aFileName ) 
       
  1614     {
 
       
  1615     iTempFileName = aFileName; 
       
  1616     iMessage->SetFileName( iTempFileName );
 
       
  1617     }
 
       
  1618 
       
  1619 // -----------------------------------------------------------------------------
 
       
  1620 // CMSRPMessageHandler::ResponseHandled
 
       
  1621 // -----------------------------------------------------------------------------
 
       
  1622 //
 
       
  1623 void CMSRPMessageHandler::ResponseHandled( )
 
       
  1624     {
 
       
  1625     delete iResponse;
 
       
  1626     iResponse = NULL;
 
       
  1627     iActiveMsgType = EMSRPMessage;
 
       
  1628     iBuffer.Zero();
 
       
  1629     }
 
       
  1630 
       
  1631 // End of file
FCL/sf/mw/ipappprotocols