1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 * Initial Contributors:

     9 * Nokia Corporation - initial contribution.

    10 * Contributors:

    11 *

    12 * Description:

    13 * MSRP Implementation

    14 *

    15 */

    16 

    17 

    18 #include "MSRPCommon.h"

    19 #include "MSRPServerCommon.h"

    20 #include "CMSRPServerSubSession.h"

    21 #include "MMSRPConnectionManager.h"

    22 #include "CMSRPServerSession.h"

    23 #include "CMSRPMessageBase.h"

    24 #include "MMSRPConnection.h"

    25 #include "CMSRPMessageHandler.h"

    26 #include "CMSRPResponse.h"

    27 #include "s32mem.h"

    28 #include "CMSRPMessage.h"

    29 #include "TStateFactory.h"

    30 #include "TStates.h"

    31 #include "CMsrpToPathHeader.h"

    32 #include "CMSRPFromPathHeader.h"

    33 

    34 

    35 CRMessageContainer::CRMessageContainer()

    36     {

    37     iStatus = FALSE;

    38     }

    39 

    40 CRMessageContainer::~CRMessageContainer()

    41     {

    42     

    43     }

    44 

    45 TInt CRMessageContainer::Write(TInt aParam,const TDesC8& aDes,TInt aOffset) const

    46     {

    47     // Write the data, change status and complete the RMessage.

    48     return iMsg.Write(aParam, aDes, aOffset);        

    49     }

    50 

    51 void CRMessageContainer:: ReadL(TInt aParam,TDes8& aDes,TInt aOffset) const

    52     {

    53     // Write the data, change status and complete the RMessage.

    54     return iMsg.ReadL(aParam, aDes, aOffset);        

    55     }

    56 

    57 void CRMessageContainer::Complete(TInt aReason)

    58     {

    59     iStatus = FALSE;

    60     iMsg.Complete(aReason);    

    61     }

    62 

    63 TBool CRMessageContainer::Check()

    64     {

    65     return iStatus;

    66     }

    67 

    68 TBool CRMessageContainer::set(const RMessage2& aMessage)

    69     {    

    70     if(FALSE == iStatus)

    71         {

    72         iMsg = aMessage; // Exclicit copy.

    73         iStatus = TRUE;

    74         return iStatus;        

    75         }

    76     else

    77         {

    78         MSRPLOG("CRMessageContainer::set Error!! Container already full");

    79         return FALSE;

    80         }    

    81     }

    82 

    83 CMSRPServerSubSession* CMSRPServerSubSession::NewL( CMSRPServerSession& aServerSession, CStateFactory& aStateFactory )

    84     {

    85     CMSRPServerSubSession* self = 

    86         CMSRPServerSubSession::NewLC( aServerSession, aStateFactory );

    87 

    88     CleanupStack::Pop(self);

    89     return self;    

    90     }    

    91 

    92 

    93 CMSRPServerSubSession* CMSRPServerSubSession::NewLC( CMSRPServerSession& aServerSession,CStateFactory& aStateFactory )

    94     {

    95     

    96     CMSRPServerSubSession* self =

    97                             new (ELeave) CMSRPServerSubSession( aServerSession, aStateFactory );

    98     CleanupStack::PushL(self);

    99     self->ConstructL();

   100     return self;

   101     }

   102 

   103 

   104 CMSRPServerSubSession::CMSRPServerSubSession( CMSRPServerSession& aServerSession,CStateFactory& aStateFactory )

   105                          : iServerSession(aServerSession), iStateFactory(aStateFactory)

   106                                               

   107     {

   108     }

   109 

   110 

   111 CMSRPServerSubSession::~CMSRPServerSubSession()

   112     {

   113     MSRPLOG("CMSRPServerSubSession::~CMSRPServerSubSession Entered");

   114     

   115     iState = NULL;         

   116 

   117     iOutMsgQ.Destroy();

   118     iInCommingMsgQ.Destroy();

   119     iPendingSendMsgQ.Destroy();

   120     iPendingForDeletionQ.Destroy();

   121 

   122     QueueLog();

   123 

   124     if(iCurrentMsgHandler)

   125         {

   126         delete iCurrentMsgHandler;

   127         iCurrentMsgHandler = NULL;

   128         }

   129     

   130     if(iConnection)

   131         {

   132         iConnection->ReleaseConnection(*this);

   133         iConnection = NULL;

   134         }

   135 

   136     if(iLocalSessionID)

   137         {

   138         delete iLocalSessionID;

   139         iLocalSessionID = NULL;

   140         }

   141 

   142     if( iRemoteSessionID )

   143         {

   144         delete iRemoteSessionID;

   145         iRemoteSessionID = NULL;

   146         }

   147 

   148     if( iReceivedResp )

   149         {

   150         delete iReceivedResp;

   151         iReceivedResp = NULL;

   152         }

   153     if( iReceiveFileMsgHdler )

   154         {

   155         delete iReceiveFileMsgHdler;

   156         iReceiveFileMsgHdler = NULL;

   157         }

   158 

   159     MSRPLOG("CMSRPServerSubSession::~CMSRPServerSubSession Exit");

   160     }

   161 

   162 

   163 void CMSRPServerSubSession::ConstructL( )

   164     {

   165     // Not the place where this should be done!!

   166     MSRPLOG("CMSRPServerSubSession::ConstructL");  

   167     iState = iStateFactory.getStateL( EIdle );

   168     iLocalSessionID = CreateSubSessionIDL();    

   169     }

   170 

   171 

   172 HBufC8* CMSRPServerSubSession::CreateSubSessionIDL( )

   173     {

   174     MSRPLOG("CMSRPServerSubSession::CreateSubSessionIDL");

   175     HBufC8 *sessID = HBufC8::NewLC(KMSRPSessIdLength);

   176     TInt64 randSeed(Math::Random());

   177     TInt rand;

   178           

   179     /* Append Random bits using two Random strings */

   180     rand = Math::Rand(randSeed);

   181     (sessID->Des()).AppendNumFixedWidth(rand,EHex,KMSRPSessIdLength/2);

   182     rand = Math::Rand(randSeed);

   183     (sessID->Des()).AppendNumFixedWidth(rand,EHex,KMSRPSessIdLength/2);

   184         

   185     CleanupStack::Pop(1);// sessID

   186     return sessID;

   187     }

   188 

   189 

   190 TBool CMSRPServerSubSession::ProcessEventL( TMSRPFSMEvent aEvent)

   191     {

   192     // Call the relevant state. Setup Traps for graceful error propagation to the client.

   193     MSRPLOG("CMSRPServerSubSession::ProcessEventL() Entered");

   194 

   195     QueueLog();    

   196             

   197     iState = iState->EventL(aEvent, this); 

   198     

   199     MSRPLOG("CMSRPServerSubSession::ProcessEventL() Exit ");

   200     return TRUE;

   201     }

   202 

   203 

   204 TBool CMSRPServerSubSession::ServiceL( const RMessage2& aMessage )

   205     {

   206     MSRPLOG("CMSRPServerSubSession::ServiceL()");

   207 

   208     // Process Client Server functions to FSM Events.

   209 

   210     // Getting rid of the switch for translation.

   211     TMSRPFSMEvent event = (TMSRPFSMEvent) (aMessage.Function() - 2); 

   212 

   213     // Store the incomming aMessage to form the context of the state machine.

   214     iClientMessage = &aMessage;        

   215         

   216     return ProcessEventL(event);    

   217     }

   218 

   219 

   220 MMSRPConnectionManager& CMSRPServerSubSession::ConnectionManager( )

   221     {

   222     return iServerSession.ConnectionManager();

   223     }

   224 

   225 

   226 // Implementation of interfaces from MMSRPConnectionObserver.

   227 void CMSRPServerSubSession::ConnectionStateL( TInt /*aNewState*/, TInt /*aStatus*/ )

   228     {    

   229     ProcessEventL(EConnectionStateChangedEvent);

   230     }

   231 

   232 

   233 TBool CMSRPServerSubSession::MessageReceivedL( CMSRPMessageHandler* aMsg )

   234     {

   235     MSRPLOG("CMSRPServerSubSession::MessageReceivedL - New message received");

   236     TBool retVal = FALSE;

   237     if(checkMessageForSelfL(aMsg))

   238         {           

   239         iReceivedMsg = aMsg;

   240         ProcessEventL(EMSRPIncomingMessageReceivedEvent);

   241         retVal = TRUE;

   242         }

   243 

   244     return retVal;    

   245     }

   246 

   247 

   248 void CMSRPServerSubSession::UnclaimedMessageL( CMSRPMessageHandler* aMsg )

   249     {

   250     MSRPLOG("CMSRPServerSubSession::UnclaimedMessage - Unclaimed message received!!");

   251     

   252     if( (aMsg->MessageType() == MMSRPIncomingMessage::EMSRPMessage ||

   253             aMsg->MessageType() == MMSRPIncomingMessage::EMSRPNotDefined )

   254             && EFalse == matchSessionIDL(aMsg->GetIncomingMessage()->ToPathHeader()))

   255         {        

   256         TBool sendToClient = aMsg->SendResponseL(this, *iConnection, 

   257                 CMSRPResponse::ESessionDoesNotExist);          

   258         iPendingForDeletionQ.Queue(*aMsg);

   259         }

   260     else

   261         {

   262         delete aMsg; 

   263         }    

   264     }

   265 

   266 

   267 // Implementation of interface from MMSRPMsgObserver.

   268 

   269 void CMSRPServerSubSession::MessageSendCompleteL()

   270     {

   271     // Called when a message is fully sent out.

   272     ProcessEventL(EMSRPDataSendCompleteEvent);

   273     }

   274 

   275 void CMSRPServerSubSession::MessageResponseSendCompleteL(CMSRPMessageHandler& aMsg)

   276     {

   277     // Called when a message is fully sent out.

   278     // Common event handling.

   279     iReceivedResp = &aMsg;

   280     if(iFileShare)

   281         {        

   282         ProcessEventL(EMSRPResponseSendCompleteEvent);

   283         }

   284         if(iPendingForDeletionQ.explicitRemove(iReceivedResp))

   285             {

   286             delete iReceivedResp;

   287             iReceivedResp = NULL;

   288             }

   289         

   290     }

   291 

   292 

   293 void CMSRPServerSubSession::MessageSendProgressL(TInt aBytesSent, TInt aTotalBytes)

   294     {

   295     iBytesTransferred = aBytesSent;

   296     iTotalBytes = aTotalBytes;

   297     ProcessEventL(EMSRPSendProgressEvent);    

   298     }

   299 

   300 

   301 void CMSRPServerSubSession::MessageReceiveProgressL(TInt aBytesRecvd, TInt aTotalBytes)

   302     {

   303     iBytesTransferred = aBytesRecvd;

   304     iTotalBytes = aTotalBytes;

   305     ProcessEventL(EMSRPReceiveProgressEvent);    

   306     }

   307 

   308 

   309 void CMSRPServerSubSession::WriterError()

   310     {

   311     

   312     }

   313 

   314 

   315 // Utility Stuff - Common functions used often by States.

   316 void CMSRPServerSubSession::CompleteClient(TInt aReason)

   317     {

   318     iClientMessage->Complete(aReason);

   319     iClientMessage = NULL;

   320     }

   321 

   322 TInt CMSRPServerSubSession::Write(TInt aParam,const TDesC8& aDes)

   323     {

   324     TInt retVal = iClientMessage->Write(aParam, aDes);  

   325     return retVal; 

   326     }

   327 

   328 

   329 TBool CMSRPServerSubSession::QueueClientSendRequestsL()

   330     {

   331     // Generic function to Queue the client send requests message. Would be used by 

   332     // many states to add to the pending client requests queue.

   333     MSRPLOG("CMSRPServerSubSession::QueueClientSendRequestsL");

   334         

   335     const RMessage2* aMessage = iClientMessage;

   336     iClientMessage = NULL;

   337 

   338     aMessage->ReadL( 0, iSendMSRPdataPckg);

   339 

   340     CMSRPMessageHandler *aMessageHandler 

   341         = CMSRPMessageHandler::NewL(this,

   342             iSendMSRPdataPckg().iExtMessageBuffer); 

   343     

   344     iPendingSendMsgQ.Queue(*aMessageHandler);    

   345     aMessage->Complete( KErrNone );        

   346         return TRUE;            

   347     }

   348 

   349 

   350 void CMSRPServerSubSession::NotifyFileReceiveResultToClientL(CMSRPMessageHandler */*msgHandler*/)

   351     {

   352     //TODO

   353     MSRPLOG("CMSRPServerSubSession::NotifyFileReceiveResultToClientL enter");

   354     iSendResultListenMSRPDataPckg().iStatus = 200;

   355     iSendResultListenMSRPDataPckg().iIsProgress = FALSE;

   356     iResponseListner.Write(0,iSendResultListenMSRPDataPckg);

   357     iResponseListner.Complete( KErrNone );

   358     MSRPLOG("CMSRPServerSubSession::NotifyFileReceiveResultToClientL exit");

   359     }

   360 

   361 

   362 void CMSRPServerSubSession::NotifyFileSendResultToClientL(CMSRPMessageHandler */*msgHandler*/)

   363     {

   364     //TODO

   365     MSRPLOG("CMSRPServerSubSession::NotifyFileSendResultToClientL enter");

   366     iSendResultListenMSRPDataPckg().iStatus = 200;

   367     iSendResultListenMSRPDataPckg().iIsProgress = FALSE;

   368     iResponseListner.Write(0,iSendResultListenMSRPDataPckg);

   369     iResponseListner.Complete( KErrNone );

   370     MSRPLOG("CMSRPServerSubSession::NotifyFileSendResultToClientL exit");

   371     }

   372 

   373 

   374 TBool CMSRPServerSubSession::SendProgressToClientL(CMSRPMessageHandler */*msgHandler*/)

   375     {

   376     MSRPLOG("CMSRPServerSubSession::SendProgressToClientL enter");

   377     iSendResultListenMSRPDataPckg().iStatus    = KErrNone;

   378     iSendResultListenMSRPDataPckg().iIsProgress = TRUE;

   379     iSendResultListenMSRPDataPckg().iBytesSent = iBytesTransferred;

   380     iSendResultListenMSRPDataPckg().iTotalBytes = iTotalBytes;

   381     

   382     iResponseListner.Write(0,iSendResultListenMSRPDataPckg);

   383     iResponseListner.Complete( KErrNone );

   384 

   385     MSRPLOG("CMSRPServerSubSession::SendProgressToClientL exit");

   386     return TRUE;

   387     }

   388 

   389 

   390 TBool CMSRPServerSubSession::ReceiveProgressToClientL(CMSRPMessageHandler */*msgHandler*/)

   391     {

   392     MSRPLOG("CMSRPServerSubSession::ReceiveProgressToClientL enter");

   393     iListenMSRPdataPckg().iStatus    = KErrNone;

   394     iListenMSRPdataPckg().iIsProgress = TRUE;

   395     iListenMSRPdataPckg().iBytesRecvd = iBytesTransferred;

   396     iListenMSRPdataPckg().iTotalBytes = iTotalBytes;

   397     

   398     iIncommingMessageListner.Write(0,iListenMSRPdataPckg);

   399     iIncommingMessageListner.Complete( KErrNone );

   400     MSRPLOG("CMSRPServerSubSession::ReceiveProgressToClientL exit");

   401     return TRUE;

   402     }

   403 

   404 

   405 TBool CMSRPServerSubSession::sendResultToClientL(CMSRPMessageHandler *msgHandler)

   406     {

   407     MSRPLOG("CMSRPServerSubSession::sendResultToClientL");

   408     HBufC8* messageId = NULL;

   409     TUint i=0;

   410 

   411     // Allocates memory.

   412     TBool error = msgHandler->GetSendResultL( i, messageId );            

   413 

   414     iSendResultListenMSRPDataPckg().iIsProgress = FALSE;

   415     iSendResultListenMSRPDataPckg().iMessageId = *messageId;

   416     iSendResultListenMSRPDataPckg().iStatus    = i;

   417     iResponseListner.Write(0,iSendResultListenMSRPDataPckg);

   418 

   419     delete messageId;

   420     iResponseListner.Complete( KErrNone );

   421     return error;

   422     }

   423 

   424 

   425 TBool CMSRPServerSubSession::sendMsgToClientL(CMSRPMessageHandler *incommingMsgHandler)

   426     {

   427     // Use the client send result listner to respond.

   428     // Extract the data and complete the iIncommingMessageListner.

   429     MSRPLOG("CMSRPServerSubSession::sendMsgToClientL");

   430     CMSRPMessage* inMsg = incommingMsgHandler->GetIncomingMessage();

   431 

   432     CBufSeg* buf1 = CBufSeg::NewL( 256 ); // expandsize 256

   433     CleanupStack::PushL( buf1 );

   434     RBufWriteStream writeStream( *buf1 );

   435     CleanupClosePushL( writeStream );

   436 

   437     inMsg->ExternalizeL( writeStream );

   438     writeStream.CommitL();

   439 

   440     iListenMSRPdataPckg().iIsProgress = FALSE;

   441     if ( buf1->Size() > KMaxLengthOfIncomingMessageExt )

   442         {

   443         // invalid message size

   444         iListenMSRPdataPckg().iStatus = KErrArgument;

   445         }

   446     else

   447         {

   448         buf1->Read( 0, iListenMSRPdataPckg().iExtMessageBuffer, buf1->Size() );

   449             iListenMSRPdataPckg().iStatus = KErrNone;            

   450         }

   451 

   452     CleanupStack::PopAndDestroy(2); // buf1, writestream    

   453    

   454     iIncommingMessageListner.Write(0,iListenMSRPdataPckg);

   455     iIncommingMessageListner.Complete(KErrNone);    

   456 

   457     return TRUE;

   458     }

   459 

   460 void CMSRPServerSubSession::ReadSendDataPckgL()

   461     {

   462     iClientMessage->ReadL( 0, iSendMSRPdataPckg);

   463     return;

   464     }

   465 

   466 TBool CMSRPServerSubSession::listnerSetupComplete()

   467     {

   468     if(iIncommingMessageListner.Check() && iResponseListner.Check())

   469         return TRUE;

   470     

   471     return FALSE;        

   472     }

   473 

   474 CMSRPServerSubSession::TQueueType CMSRPServerSubSession::getQToProcess()

   475     {

   476     // Check the pending incomming message queue and client request queue and

   477     // decides which to process.

   478     // The longer queue is given a priority. If queues are equal incomming message queue 

   479     // is given priority.

   480 

   481     if(iPendingSendMsgQ.Length() > iInCommingMsgQ.Length())

   482         return TClientQueue;

   483     else

   484         return TInCommingMsgQueue;        

   485     }

   486 

   487 

   488 TBool CMSRPServerSubSession::QueuesEmpty()

   489     {

   490     // Returns TRUE if there are no messages to process.

   491     if(iPendingSendMsgQ.isEmpty() && iInCommingMsgQ.isEmpty())

   492         return TRUE;

   493     else

   494         return FALSE;

   495     }

   496 

   497 TBool CMSRPServerSubSession::informConnectionReadyToClient()

   498     {

   499     // The function informs the Client side that the pending connection request(Connect or Listen)

   500     // is now complete. 

   501 

   502     if(EDownstream == iConnDirection)

   503         {

   504         // Case of Connect request. 

   505         iConnectionListner.Complete(KErrNone);

   506         }

   507     else

   508         {

   509         // Case of Listen.

   510         iIncommingMessageListner.Complete(KErrNone);        

   511         }

   512     return TRUE;

   513     }

   514 

   515 void CMSRPServerSubSession::QueueLog()

   516     {

   517     if(iOutMsgQ.Length() || iInCommingMsgQ.Length() || iPendingSendMsgQ.Length()||

   518         iPendingForDeletionQ.Length())

   519         {

   520         // If any of the Queue is not empty. Log a event.

   521         MSRPLOG2("CMSRPServerSubSession::ProcessEventL() Queue iOutMsgQ       %d",

   522                     iOutMsgQ.Length());

   523         

   524         MSRPLOG2("CMSRPServerSubSession::ProcessEventL() Queue iInCommingMsgQ %d",

   525                     iInCommingMsgQ.Length());

   526         

   527         MSRPLOG2("CMSRPServerSubSession::ProcessEventL() Queue iPendingSendMsgQ %d",

   528                     iPendingSendMsgQ.Length());

   529 

   530         MSRPLOG2("CMSRPServerSubSession::ProcessEventL() Queue iPendingForDeletionQ %d",

   531                     iPendingForDeletionQ.Length());

   532         }

   533     else

   534         {

   535         MSRPLOG("CMSRPServerSubSession::ProcessEventL() Queue All Empty");

   536         }        

   537     }

   538 

   539 

   540 TBool CMSRPServerSubSession::checkMessageForSelfL(CMSRPMessageHandler *aMsgHandler)

   541     {

   542     MSRPLOG("CMSRPServerSubSession::checkMessageForSelfL");

   543     CMSRPMessageBase *message = aMsgHandler->GetIncomingResponse();

   544     if(!message)

   545         { 

   546         message = aMsgHandler->GetIncomingMessage();

   547         }

   548     

   549     if(!message)

   550         return FALSE;

   551 

   552     // Check if the sessionID in the 'To' path matches the LocalSessionID.

   553     if(FALSE == matchSessionIDL(message->ToPathHeader()))

   554         return FALSE;

   555 

   556     // Check if the sessionID in the 'From' path matches the known RemoteSessionID.

   557     return matchSessionIDL(message->FromPathHeader(), FALSE);            

   558     }

   559 

   560 

   561 TBool CMSRPServerSubSession::matchSessionIDL(const CMSRPHeaderBase *aPathHeader, TBool local)

   562     {

   563     TBool retVal = FALSE;

   564     

   565     HBufC8* textValue = aPathHeader->ToTextValueLC();        

   566     TPtrC8 receivedSessionID = extractSessionID(*textValue);    

   567     

   568     if(local && receivedSessionID  == *iLocalSessionID)

   569         retVal =  TRUE;

   570 

   571     

   572     if(!local && receivedSessionID == *iRemoteSessionID)

   573         retVal =  TRUE;

   574 

   575     CleanupStack::PopAndDestroy(textValue);

   576 

   577     return retVal;

   578     }

   579 

   580 

   581 TPtrC8 CMSRPServerSubSession::extractSessionID(const TDesC8& aPathBuffer)

   582     {

   583     // Extracts the sessionId from aPathBuffer and matches it again

   584     TInt posEndOfSessionString   = 

   585                 aPathBuffer.LocateReverseF(KSemiColonCharacter);

   586     TInt posStartOfSessionString = 

   587                 aPathBuffer.LocateReverseF(KDividedCharacter) + 1;

   588 

   589     TPtrC8 receivedSessionId = aPathBuffer.Mid(posStartOfSessionString, \

   590         (posEndOfSessionString - posStartOfSessionString));

   591 

   592     return receivedSessionId;

   593     }

   594 

   595 

   596 CStateFactory& CMSRPServerSubSession::StateFactory()

   597     {

   598     return iStateFactory;

   599     }

   600