1 /*

     2 * Copyright (c) 2009 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 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description: This file conatins StifTfIfProt implementation.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <e32base.h>

    20 #include <e32svr.h>

    21 #include "StifTFwIfProt.h"

    22 

    23 #include <StifLogger.h>

    24 

    25 // EXTERNAL DATA STRUCTURES

    26 //extern  ?external_data;

    27 

    28 // EXTERNAL FUNCTION PROTOTYPES  

    29 //extern ?external_function( ?arg_type,?arg_type );

    30 

    31 // CONSTANTS

    32 //const ?type ?constant_var = ?constant;

    33 

    34 // MACROS

    35 //#define DEBUG(a) RDebug::Print(a)

    36 //#define DEBUG2(a,b) RDebug::Print(a,b)

    37 //#define DEBUG3(a,b,c) RDebug::Print(a,b,c)

    38 #define DEBUG(a)

    39 #define DEBUG2(a,b)

    40 #define DEBUG3(a,b,c)

    41 #define ERROR RDebug::Print

    42 

    43 // LOCAL CONSTANTS AND MACROS

    44 //const ?type ?constant_var = ?constant;

    45 //#define ?macro_name ?macro_def

    46 

    47 // MODULE DATA STRUCTURES

    48 //enum ?declaration

    49 //typedef ?declaration

    50 

    51 // LOCAL FUNCTION PROTOTYPES

    52 //?type ?function_name( ?arg_type, ?arg_type );

    53 

    54 // FORWARD DECLARATIONS

    55 //class ?FORWARD_CLASSNAME;

    56 

    57 // ==================== LOCAL FUNCTIONS =======================================

    58 

    59 /*

    60 -------------------------------------------------------------------------------

    61 

    62     Function: <function name>

    63 

    64     Description: <one line description>

    65 

    66     <Description of the functionality 

    67     description continues and...

    68     continues>

    69 

    70     Parameters:	<arg1>: <in/out/inout>: <accepted values>: <Description>

    71     

    72     Return Values: <value_1: Description

    73 		            value_n: Description line 1

    74 			                 description line 2>

    75 

    76     Errors/Exceptions: <description how errors and exceptions are handled>

    77 

    78     Status: Draft

    79 

    80 -------------------------------------------------------------------------------

    81 */

    82 /*

    83 <type function_name(

    84     <arg_type arg,>  

    85     <arg_type arg >)  	

    86     {

    87     // <comment>

    88     <code> 

    89     

    90     // <comment>

    91     <code>

    92     }

    93 */

    94 

    95 

    96 /*

    97 -------------------------------------------------------------------------------

    98 

    99     DESCRIPTION

   100 

   101     This module contains the implementation of CStifTFwIfProt class 

   102 	member functions.

   103 

   104 -------------------------------------------------------------------------------

   105 */

   106 

   107 // ================= MEMBER FUNCTIONS =========================================

   108 

   109 /*

   110 -------------------------------------------------------------------------------

   111 

   112     Class: CStifTFwIfProt

   113 

   114     Method: CStifTFwIfProt

   115 

   116     Description: Default constructor

   117 

   118     C++ default constructor can NOT contain any code, that

   119     might leave.

   120     

   121     Parameters:	none

   122     

   123     Return Values: None

   124     

   125     Errors/Exceptions: None

   126     

   127     Status: Draft

   128 	

   129 -------------------------------------------------------------------------------

   130 */

   131 CStifTFwIfProt::CStifTFwIfProt(): iMessage(0,0)

   132     { 

   133     };

   134     

   135 /*

   136 -------------------------------------------------------------------------------

   137 

   138      Class: CStifTFwIfProt

   139 

   140      Method: ConstructL

   141 

   142      Description: Symbian OS second phase constructor

   143 

   144      Symbian OS default constructor can leave.

   145 

   146      Parameters:    None

   147 

   148      Return Values: None

   149 

   150      Errors/Exceptions: None.

   151 

   152      Status: Proposal

   153     

   154 -------------------------------------------------------------------------------

   155 */

   156 void CStifTFwIfProt::ConstructL()

   157     {        

   158 

   159     }

   160 

   161 /*

   162 -------------------------------------------------------------------------------

   163 

   164      Class: CStifTFwIfProt

   165 

   166      Method: NewL

   167 

   168      Description: Two-phased constructor.

   169           

   170      Parameters:    None

   171 

   172      Return Values: CStifTFwIfProt*: new object

   173 

   174      Errors/Exceptions: Leaves if new or ConstructL leaves and in oom.

   175 

   176      Status: Proposal

   177     

   178 -------------------------------------------------------------------------------

   179 */

   180 EXPORT_C CStifTFwIfProt* CStifTFwIfProt::NewL()

   181     {

   182      

   183     CStifTFwIfProt* self = new (ELeave) CStifTFwIfProt();

   184     

   185     CleanupStack::PushL( self );

   186     self->ConstructL();

   187     CleanupStack::Pop();

   188 

   189     return self;

   190      

   191     }

   192 

   193 /*

   194 -------------------------------------------------------------------------------

   195 

   196     Class: CStifTFwIfProt

   197 

   198     Method: ~CStifTFwIfProt

   199 

   200     Description: Destructor

   201 

   202     Parameters:	None

   203     

   204     Return Values: None

   205     

   206     Errors/Exceptions: None

   207     

   208     Status: Draft

   209 	

   210 -------------------------------------------------------------------------------

   211 */    

   212 

   213 EXPORT_C CStifTFwIfProt::~CStifTFwIfProt()

   214     {

   215     

   216     delete iItem;

   217     delete iMessageBuf;

   218     iMessageBuf = NULL;

   219     

   220     }

   221 

   222 /*

   223 -------------------------------------------------------------------------------

   224 

   225     Class: CStifTFwIfProt

   226 

   227     Method: CreateL

   228 

   229     Description: Create new empty protocol message.

   230 

   231     Parameters:	TInt aLength: in: protocol message length

   232     

   233     Return Values: None

   234     

   235     Errors/Exceptions: Leave if oom.

   236     

   237     Status: Draft

   238 	

   239 -------------------------------------------------------------------------------

   240 */

   241 EXPORT_C void CStifTFwIfProt::CreateL( TInt aLength )

   242     {

   243     

   244     // Delete previous if exists

   245     delete iMessageBuf;

   246     iMessageBuf = NULL;

   247     iMessage.Set( 0, 0, 0 );

   248     

   249     iMessageBuf = HBufC::NewL( aLength );

   250     iMessage.Set( iMessageBuf->Des() );

   251             

   252     }

   253 

   254 /*

   255 -------------------------------------------------------------------------------

   256 

   257     Class: CStifTFwIfProt

   258 

   259     Method: Append

   260 

   261     Description: Append string to protocol message.

   262 

   263     Parameters:	TInt aLength: in: protocol message length

   264     

   265     Return Values: None

   266     

   267     Errors/Exceptions: Leave if oom.

   268     

   269     Status: Draft

   270 	

   271 -------------------------------------------------------------------------------

   272 */   

   273 EXPORT_C TInt CStifTFwIfProt::Append( const TDesC& aStr )

   274     {

   275     

   276     if( ( aStr.Length() + 1 ) >

   277         ( iMessage.MaxLength() - iMessage.Length() ) )

   278         {

   279         ERROR( _L("No space left for string") );

   280         return KErrOverflow;   

   281         }

   282     iMessage.Append( aStr );

   283     iMessage.Append( _L(" ") );

   284     

   285     return KErrNone;

   286 

   287     }    

   288 

   289 /*

   290 -------------------------------------------------------------------------------

   291 

   292     Class: CStifTFwIfProt

   293 

   294     Method: Append

   295 

   296     Description: Append hexadecimal value to protocol message.

   297 

   298     Parameters:	TInt aLength: in: protocol message length

   299     

   300     Return Values: None

   301     

   302     Errors/Exceptions: Leave if oom.

   303     

   304     Status: Draft

   305 	

   306 -------------------------------------------------------------------------------

   307 */   

   308 EXPORT_C TInt CStifTFwIfProt::AppendId( TUint32 aId )

   309     {

   310     

   311      if( ( KMaxValueLength + 1 ) >

   312         ( iMessage.MaxLength() - iMessage.Length() ) )

   313         {

   314         ERROR( _L("No space left for string") );

   315         return KErrOverflow;   

   316         }

   317         

   318     iMessage.AppendNumFixedWidth( aId, EHex, KProtocolIdLength );

   319     iMessage.Append( _L(" ") );

   320     

   321     return KErrNone;

   322 

   323     }

   324         

   325 /*

   326 -------------------------------------------------------------------------------

   327 

   328     Class: CStifTFwIfProt

   329 

   330     Method: Append

   331 

   332     Description: Append string to protocol message.

   333 

   334     Parameters:	TInt aLength: in: protocol message length

   335     

   336     Return Values: None

   337     

   338     Errors/Exceptions: Leave if oom.

   339 

   340     Status: Draft

   341 	

   342 -------------------------------------------------------------------------------

   343 */   

   344 EXPORT_C TInt CStifTFwIfProt::Append( KeywordFunc aFunc, TInt aKeyword )

   345     {

   346     

   347     if( ( aFunc( aKeyword ).Length() + 1 ) >

   348         ( iMessage.MaxLength() - iMessage.Length() ) )

   349         {

   350         ERROR( _L("No space left for string") );

   351         return KErrOverflow;   

   352         }

   353     iMessage.Append( aFunc( aKeyword ) );

   354     iMessage.Append( _L(" ") );

   355     

   356     return KErrNone;

   357 

   358     }

   359     

   360 /*

   361 -------------------------------------------------------------------------------

   362 

   363     Class: CStifTFwIfProt

   364 

   365     Method: Append

   366 

   367     Description: Append type-value string to protocol message.

   368 

   369     Parameters:	TInt aLength: in: protocol message length

   370     

   371     Return Values: None

   372     

   373     Errors/Exceptions: Leave if oom.

   374     

   375     Status: Draft

   376 	

   377 -------------------------------------------------------------------------------

   378 */   

   379 EXPORT_C TInt CStifTFwIfProt::Append( KeywordFunc aFunc, 

   380                                       TInt aKeyword, 

   381                                       const TDesC& aStr )

   382     {

   383     

   384      if( ( aFunc( aKeyword ).Length() + 2 +  aStr.Length() ) >

   385         ( iMessage.MaxLength() - iMessage.Length() ) )

   386         {

   387         ERROR( _L("No space left for string") );

   388         return KErrOverflow;

   389         }

   390         

   391     iMessage.Append( aFunc( aKeyword ) );

   392     iMessage.Append( _L("=") );

   393     iMessage.Append( aStr );

   394     iMessage.Append( _L(" ") );

   395     

   396     return KErrNone;

   397 

   398     }

   399     

   400 /*

   401 -------------------------------------------------------------------------------

   402 

   403     Class: CStifTFwIfProt

   404 

   405     Method: Append

   406 

   407     Description: Append type-value string to protocol message.

   408 

   409     Parameters:	TInt aLength: in: protocol message length

   410     

   411     Return Values: None

   412     

   413     Errors/Exceptions: Leave if oom.

   414     

   415     Status: Draft

   416 	

   417 -------------------------------------------------------------------------------

   418 */   

   419 EXPORT_C TInt CStifTFwIfProt::Append( KeywordFunc aFunc, 

   420                                       TInt aKeyword, 

   421                                       KeywordFunc aValueFunc, 

   422                                       TInt aValue )

   423     {

   424     

   425      if( ( aFunc( aKeyword ).Length() + 2 +  aValueFunc( aValue ).Length() ) >

   426         ( iMessage.MaxLength() - iMessage.Length() ) )

   427         {

   428         ERROR( _L("No space left for string") );

   429         return KErrOverflow;   

   430         }

   431         

   432     iMessage.Append( aFunc( aKeyword ) );

   433     iMessage.Append( _L("=") );

   434     iMessage.Append( aValueFunc( aValue ) );

   435     iMessage.Append( _L(" ") );

   436     

   437     return KErrNone;

   438 

   439     }

   440 

   441 /*

   442 -------------------------------------------------------------------------------

   443 

   444     Class: CStifTFwIfProt

   445 

   446     Method: Append

   447 

   448     Description: Append type-value string to protocol message.

   449 

   450     Parameters:	TInt aLength: in: protocol message length

   451     

   452     Return Values: None

   453     

   454     Errors/Exceptions: Leave if oom.

   455     

   456     Status: Draft

   457 	

   458 -------------------------------------------------------------------------------

   459 */   

   460 EXPORT_C TInt CStifTFwIfProt::Append( KeywordFunc aFunc, 

   461                                        TInt aKeyword, 

   462                                        TInt aValue )

   463     {

   464     

   465      if( ( aFunc( aKeyword ).Length() + 2 + KMaxValueLength ) >

   466         ( iMessage.MaxLength() - iMessage.Length() ) )

   467         {

   468         ERROR( _L("No space left for string") );

   469         return KErrOverflow;   

   470         }

   471         

   472     iMessage.Append( aFunc( aKeyword ) );

   473     iMessage.Append( _L("=") );

   474     iMessage.AppendNum( aValue );

   475     iMessage.Append( _L(" ") );

   476     

   477     return KErrNone;

   478 

   479     }

   480         

   481 /*

   482 -------------------------------------------------------------------------------

   483 

   484     Class: CStifTFwIfProt

   485 

   486     Method: SetL

   487 

   488     Description: Set and parse protocol message.

   489 

   490     Parameters:	TDesC& aMessage: in: protocol message

   491     

   492     Return Values: Symbian OS error code: If protocol message parsing fails, 

   493         i.e. message prsing after header <msg type> <sdcid> <dstid>

   494     

   495     Errors/Exceptions: Leaves if protocol header parsing fails and oom.

   496     

   497     Status: Draft

   498 	

   499 -------------------------------------------------------------------------------

   500 */

   501 EXPORT_C TInt CStifTFwIfProt::SetL( const TDesC& aMessage )

   502     {

   503     

   504     // Delete previous if exists

   505     delete iMessageBuf;

   506     iMessageBuf = NULL;

   507     iMessage.Set( 0,0,0 );

   508     

   509     iMessageBuf = aMessage.AllocL();

   510     iMessage.Set( iMessageBuf->Des() );

   511     

   512     return ParseMessageL();

   513         

   514     }

   515             

   516 /*

   517 -------------------------------------------------------------------------------

   518 

   519     Class: CStifTFwIfProt

   520 

   521     Method: SetL

   522 

   523     Description: Get protocol source identifier.

   524 

   525     Parameters:	None

   526     

   527     Return Values: Source identifier.

   528     

   529     Errors/Exceptions: None.

   530 

   531     Status: Draft

   532 	

   533 -------------------------------------------------------------------------------

   534 */

   535 EXPORT_C TUint32 CStifTFwIfProt::SrcId()

   536     {

   537     

   538     return iSrcId;    

   539     

   540     }

   541 

   542 /*

   543 -------------------------------------------------------------------------------

   544 

   545     Class: CStifTFwIfProt

   546 

   547     Method: SetL

   548 

   549     Description: Get protocol source device identifier.

   550 

   551     Parameters:	None

   552     

   553     Return Values: Source device identifier.

   554     

   555     Errors/Exceptions: None.

   556     

   557     Status: Draft

   558 	

   559 -------------------------------------------------------------------------------

   560 */

   561 EXPORT_C TUint16 CStifTFwIfProt::SrcDevId()

   562     {

   563     

   564     return DEVID( iSrcId );  

   565         

   566     }

   567 

   568 /*

   569 -------------------------------------------------------------------------------

   570 

   571     Class: CStifTFwIfProt

   572 

   573     Method: SetL

   574 

   575     Description: Get protocol source test identifier.

   576 

   577     Parameters:	None

   578     

   579     Return Values: Source test identifier.

   580     

   581     Errors/Exceptions: None.

   582 

   583     Status: Draft

   584 

   585 -------------------------------------------------------------------------------

   586 */

   587 EXPORT_C TUint16 CStifTFwIfProt::SrcTestId()

   588     {

   589 

   590     return TESTID( iSrcId );  

   591     

   592     }

   593 

   594 /*

   595 -------------------------------------------------------------------------------

   596 

   597     Class: CStifTFwIfProt

   598 

   599     Method: SetL

   600 

   601     Description: Get protocol destination identifier.

   602 

   603     Parameters:	None

   604     

   605     Return Values: Destination identifier.

   606     

   607     Errors/Exceptions: None.

   608 

   609     Status: Draft

   610 	

   611 -------------------------------------------------------------------------------

   612 */

   613 EXPORT_C TUint32 CStifTFwIfProt::DstId()

   614     {

   615     

   616     return iDstId;  

   617 

   618     }

   619 

   620 /*

   621 -------------------------------------------------------------------------------

   622 

   623     Class: CStifTFwIfProt

   624 

   625     Method: SetL

   626 

   627     Description: Get protocol destination device identifier.

   628 

   629     Parameters:	None

   630     

   631     Return Values: Destination device identifier.

   632     

   633     Errors/Exceptions: None.

   634 

   635     Status: Draft

   636 	

   637 -------------------------------------------------------------------------------

   638 */

   639 EXPORT_C TUint16 CStifTFwIfProt::DstDevId()

   640     {

   641 

   642     return DEVID( iDstId );  

   643 

   644     }

   645 

   646 /*

   647 -------------------------------------------------------------------------------

   648 

   649     Class: CStifTFwIfProt

   650 

   651     Method: SetL

   652 

   653     Description: Get protocol destination test identifier.

   654 

   655     Parameters:	None

   656     

   657     Return Values: Destination test identifier.

   658     

   659     Errors/Exceptions: None.

   660 

   661     Status: Draft

   662 	

   663 -------------------------------------------------------------------------------

   664 */

   665 EXPORT_C TUint16 CStifTFwIfProt::DstTestId()

   666     {

   667 

   668     return TESTID( iDstId );  

   669     

   670     }

   671 

   672 

   673 /*

   674 -------------------------------------------------------------------------------

   675 

   676     Class: CStifTFwIfProt

   677 

   678     Method: ParseMessageL

   679 

   680     Description: Parse protocol message.

   681 

   682     Parameters:	None

   683 

   684     Return Values: None.

   685 

   686     Errors/Exceptions: None.

   687 

   688     Status: Draft

   689 

   690 -------------------------------------------------------------------------------

   691 */

   692 TInt CStifTFwIfProt::ParseMessageL()

   693     {

   694     RDebug::Print(_L("CStifTFwIfProt::ParseMessageL start"));

   695 

   696     RDebug::Print(_L("CStifTFwIfProt::ParseMessageL message content: (next line)"));

   697     RDebug::Print(iMessage);

   698 

   699     iItem = CStifItemParser::NewL( iMessage, 0, iMessage.Length() );

   700 

   701     ParseHeaderL();

   702 

   703     TRAPD( err,

   704     switch( iMsgType )

   705         {

   706         case EMsgReserve:

   707             RDebug::Print(_L("CStifTFwIfProt::ParseMessageL EMsgReserve"));

   708             ParseReserveL();

   709             break;

   710         case EMsgRelease:

   711             RDebug::Print(_L("CStifTFwIfProt::ParseMessageL EMsgRelease"));

   712             break;

   713         case EMsgRemote:

   714             RDebug::Print(_L("CStifTFwIfProt::ParseMessageL EMsgRemote"));

   715             ParseRemoteL();

   716             break;

   717         case EMsgResponse:

   718             RDebug::Print(_L("CStifTFwIfProt::ParseMessageL EMsgResponse"));

   719             ParseResponseL();

   720             break;

   721         default:

   722             RDebug::Print(_L("CStifTFwIfProt::ParseMessageL ERROR invalid message type. Leaving!!!"));

   723             ERROR( _L("Invalid message type") );        

   724             User::Leave( KErrArgument );

   725         }

   726     );

   727     

   728     delete iItem;

   729     iItem = 0;

   730     

   731     return err;

   732            

   733     }

   734     

   735 /*

   736 -------------------------------------------------------------------------------

   737 

   738     Class: CStifTFwIfProt

   739 

   740     Method: ParseHeaderL

   741 

   742     Description: Parse protocol header.

   743 

   744     Parameters:	None

   745     

   746     Return Values: None.

   747     

   748     Errors/Exceptions: None.

   749     

   750     Status: Draft

   751 	

   752 -------------------------------------------------------------------------------

   753 */

   754 void CStifTFwIfProt::ParseHeaderL()

   755     {

   756     

   757     TPtrC tmp;

   758     TInt ret;

   759     TInt tmpMsgType;

   760     

   761     // Get and parse message type    

   762     ret = iItem->GetString( _L(""), tmp );

   763     if( ret != KErrNone )

   764         {

   765         ERROR( _L("No message type given") );        

   766         User::Leave( KErrNotFound );

   767         }

   768         

   769     tmpMsgType = Parse( tmp, MsgType );

   770     if( tmpMsgType < 0 )

   771         {

   772         ERROR( _L("Invalid message type given") );        

   773         User::Leave( KErrArgument );

   774         }

   775 	iMsgType = ( TMsgType )tmpMsgType;

   776 

   777     // Get and parse srcid    

   778     ret = iItem->GetNextString( tmp );

   779     if( ret != KErrNone )

   780         {

   781         ERROR( _L("No srcid given") );        

   782         User::Leave( KErrNotFound );

   783         }

   784     // Check id length

   785     if( tmp.Length() != KProtocolIdLength )

   786         {

   787         ERROR( _L("Invalid srcid length [%d]"), tmp.Length() );        

   788         User::Leave( KErrArgument );

   789         }    

   790     TUint32 id;

   791     TLex lex( tmp );

   792     if( lex.Val( id, EHex ) != KErrNone )

   793         {

   794         ERROR( _L("Invalid srcid given") );        

   795         User::Leave( KErrArgument );

   796         }        

   797     iSrcId = id;

   798 

   799 

   800     // Get and parse dstid    

   801     ret = iItem->GetNextString( tmp );

   802     if( ret != KErrNone )

   803         {

   804         ERROR( _L("No dstid given") );        

   805         User::Leave( KErrNotFound );

   806         }

   807     // Check id length

   808     if( tmp.Length() != KProtocolIdLength )

   809         {

   810         ERROR( _L("Invalid srcid length [%d]"), tmp.Length() );        

   811         User::Leave( KErrArgument );

   812         }                    

   813     lex.Assign( tmp );

   814     if( lex.Val( id, EHex ) != KErrNone )

   815         {

   816         ERROR( _L("Invalid dstid given") );        

   817         User::Leave( KErrArgument );

   818         }        

   819     iDstId = id;

   820     

   821     }

   822     

   823     

   824 /*

   825 -------------------------------------------------------------------------------

   826 

   827     Class: CStifTFwIfProt

   828 

   829     Method: ParseReserveL

   830 

   831     Description: Parse protocol reserve message.

   832 

   833     Parameters:	None

   834     

   835     Return Values: None.

   836     

   837     Errors/Exceptions: None.

   838     

   839     Status: Draft

   840 	

   841 -------------------------------------------------------------------------------

   842 */

   843 void CStifTFwIfProt::ParseReserveL()

   844     {

   845     

   846     TPtrC tmp;

   847     TInt ret;

   848 	TInt tmpRemoteType;

   849     

   850     // Get and parse remote type    

   851     ret = iItem->GetNextString( tmp );

   852     if( ret != KErrNone )

   853         {

   854         ERROR( _L("No remote type given") );        

   855         User::Leave( KErrNotFound );

   856         }

   857             

   858     tmpRemoteType = Parse( tmp, RemoteType );

   859     if( tmpRemoteType < 0 )

   860         {

   861         iRemoteType = ERemoteUnknown;

   862         }

   863     else 

   864     	{

   865     	iRemoteType = ( TRemoteType ) tmpRemoteType;

   866     	}

   867         

   868     }

   869     

   870 /*

   871 -------------------------------------------------------------------------------

   872 

   873     Class: CStifTFwIfProt

   874 

   875     Method: ParseRemoteL

   876 

   877     Description: Parse protocol remote message.

   878 

   879     Parameters:	None

   880     

   881     Return Values: None.

   882     

   883     Errors/Exceptions: None.

   884     

   885     Status: Draft

   886 	

   887 -------------------------------------------------------------------------------

   888 */

   889 void CStifTFwIfProt::ParseRemoteL()

   890     {

   891     RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL start"));

   892 

   893     TPtrC tmp;

   894     TInt ret;

   895     TInt tmpCmdType;

   896 

   897     // Set mode of item parser to be able to read titles with spaces inside

   898     iItem->SetParsingType(CStifItemParser::EQuoteStyleParsing);

   899 

   900     // Get and parse command

   901     ret = iItem->GetNextString( tmp );

   902     if( ret != KErrNone )

   903         {

   904         ERROR( _L("No command given") );

   905         User::Leave( KErrNotFound );

   906         }

   907 

   908     iCmdDes.Set( tmp );

   909     tmpCmdType = Parse( tmp, CmdType );

   910     RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL readed command %d"), tmpCmdType);

   911     if( tmpCmdType < 0 )

   912         {

   913         iCmdType = ECmdUnknown;

   914         DEBUG( _L("Unknown command given") );        

   915         }

   916     else

   917     	{

   918     	iCmdType = ( TCmdType ) tmpCmdType;

   919     	}

   920         

   921     switch( iCmdType )

   922         {

   923         case ECmdRun:

   924             {

   925             RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL iCmdType ECmdRun"));

   926             // Parse run parameters

   927             TPtrC arg; 

   928             TPtrC val;

   929             iTestCaseNumber = KErrNotFound;

   930             while( iItem->GetNextString( tmp ) == KErrNone )

   931                 {

   932                 if( ParseOptArg( tmp, arg, val ) == KErrNone )

   933                     {              

   934                     TInt param = Parse( arg, RunParams );

   935                     if( param < 0 )

   936                         {

   937                         ERROR( _L("Invalid run parameter given") );        

   938                         User::Leave( KErrArgument );

   939                         }

   940                     

   941                     switch( param )

   942                         {

   943                         case ERunModule:

   944                             iModule.Set( val );

   945                             break;

   946                         case ERunInifile:

   947                             iIniFile.Set( val );

   948                             break;

   949                         case ERunTestcasefile:

   950                             iTestCaseFile.Set( val );

   951                             break;

   952                         case ERunTestcasenum:

   953                             {

   954                             TLex ptr( val );

   955                             if( ptr.Val( iTestCaseNumber ) != KErrNone )

   956                                 {

   957                                 ERROR( _L("Invalid test case number given") );        

   958                                 User::Leave( KErrArgument );

   959                                 }  

   960                             }

   961                             break;

   962                         case ERunTitle:

   963                             iTitle.Set(val);

   964                             break;

   965                         default:

   966                             ERROR( _L("Invalid run parameter given") );        

   967                             User::Leave( KErrArgument );

   968                         }

   969                     }

   970                 else

   971                     {

   972                     ERROR( _L("Invalid run parameter given") );        

   973                     User::Leave( KErrArgument );

   974                     }

   975                 }

   976             if( iModule.Length() == 0 )

   977                 {

   978                 ERROR( _L("No mandatory test module name given as run parameter") );        

   979                 //User::Leave( KErrNotFound );

   980                 }    

   981             if(iTestCaseNumber < 0 && iTitle.Length() == 0) //No test case number and no title

   982                 {

   983                 ERROR( _L("No mandatory test case number given as run parameter") );        

   984                 //User::Leave( KErrNotFound );

   985                 }    

   986             }   

   987             break;

   988         case ECmdPause:

   989         case ECmdResume:

   990         case ECmdCancel:

   991             RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL iCmdType ECmdPause,Resume,Cancel"));

   992             break;

   993         case ECmdRequest:

   994         case ECmdRelease:

   995             RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL iCmdType ECmdRequest,Release"));

   996             ret = iItem->GetNextString( tmp );

   997             if( ret != KErrNone )

   998                 {

   999                 ERROR( _L("No event name given") );        

  1000                 //User::Leave( KErrNotFound );

  1001                 iEventName.Set( 0, 0 );

  1002                 }

  1003             else

  1004                 {

  1005                 iEventName.Set( tmp );

  1006                 }

  1007             break;

  1008         case ECmdSendReceive:

  1009             {

  1010             RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL iCmdType ECmdSendReceive"));

  1011             DEBUG( _L("sendreceive") );

  1012             break;

  1013             }

  1014         default:

  1015             RDebug::Print(_L("CStifTFwIfProt::ParseRemoteL iCmdType UNKNOWN!!!"));

  1016             DEBUG( _L("Unknown command") );

  1017             break;

  1018         }

  1019     }    

  1020     

  1021 /*

  1022 -------------------------------------------------------------------------------

  1023 

  1024     Class: CStifTFwIfProt

  1025 

  1026     Method: ParseResponseL

  1027 

  1028     Description: Parse protocol response message.

  1029 

  1030     Parameters:	None

  1031     

  1032     Return Values: None.

  1033     

  1034     Errors/Exceptions: None.

  1035     

  1036     Status: Draft

  1037 	

  1038 -------------------------------------------------------------------------------

  1039 */

  1040 void CStifTFwIfProt::ParseResponseL()

  1041     {

  1042 

  1043     TPtrC tmp;

  1044     TInt ret;

  1045     TInt tmpRespType;

  1046     TInt tmpCmdType;

  1047 

  1048     // Get and parse request response type

  1049     ret = iItem->GetNextString( tmp );

  1050     if( ret != KErrNone )

  1051         {

  1052         ERROR( _L("No request type given") );

  1053         User::Leave( KErrNotFound );

  1054         }

  1055 

  1056     tmpRespType = Parse( tmp, MsgType );

  1057     if( tmpRespType < 0 )

  1058         {

  1059         ERROR( _L("Invalid request type given") );

  1060         User::Leave( KErrArgument );

  1061         }

  1062     else

  1063     	{

  1064     	iRespType = ( TMsgType ) tmpRespType;

  1065     	}

  1066 

  1067     ret = iItem->GetNextString( tmp );

  1068 

  1069     // First check if this is a response to a remote command

  1070     if( iRespType == EMsgRemote )

  1071         {

  1072         if( ret != KErrNone )

  1073             {

  1074             ERROR( _L("No arguments for remote response given") );

  1075             User::Leave( KErrNotFound );

  1076             }

  1077 

  1078         iCmdDes.Set( tmp );

  1079         tmpCmdType = Parse( tmp, CmdType );;

  1080         if( tmpCmdType >= 0 )

  1081             {

  1082 			iCmdType = ( TCmdType ) tmpCmdType;

  1083             DEBUG2( _L("Remote response for %S"), &tmp );

  1084             ParseCmdResponseL();

  1085             // Get and parse general response parameters

  1086             ret = iItem->GetNextString( tmp );

  1087             }

  1088         else

  1089             {

  1090             iCmdType = (TCmdType)KErrNotFound;

  1091             }

  1092         }

  1093     while( ret == KErrNone )

  1094         {

  1095         TPtrC arg;

  1096         TPtrC val;

  1097         if( ParseOptArg( tmp, arg, val ) == KErrNone )

  1098             {              

  1099             TInt param = Parse( arg, RespParam );

  1100             if( param < 0 )

  1101                 {

  1102                 ERROR( _L("Invalid parameter given") );        

  1103                 User::Leave( KErrArgument );

  1104                 }

  1105             

  1106             switch( param )

  1107                 {

  1108                 case ERespResult:

  1109                     {

  1110                     TLex ptr( val );

  1111                     if( ptr.Val( iResult ) != KErrNone )

  1112                         {

  1113                         ERROR( _L("Invalid error code given") );        

  1114                         User::Leave( KErrArgument );

  1115                         }   

  1116                     }

  1117                     break;

  1118                 default:

  1119                     ERROR( _L("Invalid parameter given") );        

  1120                     User::Leave( KErrArgument );

  1121                 }       

  1122             }

  1123 #if 0 // Check all parameters anyway

  1124         else 

  1125             {

  1126             ERROR( _L("Invalid parameter given") );        

  1127             User::Leave( KErrArgument ); 

  1128             }

  1129 #endif

  1130         ret = iItem->GetNextString( tmp );

  1131 

  1132         }

  1133     

  1134     }