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 the License "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: 

    15 *

    16 */

    17 

    18 

    19 #include "tisi.h"

    20 #include "isimessagetrace.h"

    21 #include <pn_const.h>

    22 #include "osttracedefinitions.h"

    23 #ifdef OST_TRACE_COMPILER_IN_USE

    24 #include "tisitraces.h"

    25 #endif

    26 

    27 

    28 

    29 //  LOCAL CONSTANTS AND MACROS  

    30 

    31 const TInt KMessageHeaderLength ( 6 );

    32 const TUint16 KSixteenBitZero ( 0x0000 );

    33 const TUint32 KThirtytwoBitZero ( 0x00000000 );

    34 const TInt KMinSbLength ( 4 );

    35 const TUint8 KPaddingByte ( 0x00 );

    36 

    37 #define IS_DEV_HOST( dev )            ( ( dev & 0xF0 ) == 0 )

    38 #define GET_RECEIVER_DEV( msg )       ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0xFC )

    39 #define GET_SENDER_DEV( msg )         ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0xFC )

    40 #define GET_RECEIVER_OBJ( msg )       IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] ) ? \

    41                                       ( ( TUint16 )msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] + ( ( msg [ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x0F ) << 8 ) ) : \

    42                                       ( ( TUint16 )msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] + ( ( msg [ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x03 ) << 8 ) )

    43 #define GET_SENDER_OBJ( msg )         IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] ) ? \

    44                                       ( ( TUint16 )msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] + ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x0F ) << 8 ) ) : \

    45                                       ( ( TUint16 )msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] + ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x03 ) << 8 ) )

    46 #define SET_RECEIVER_DEV( msg, dev )  ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE] = ( ( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] & 0x03 ) | ( ( dev ) & 0xFC ) ) )

    47 #define SET_SENDER_DEV( msg, dev )    ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE] = ( ( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] & 0x03 ) | ( ( dev ) & 0xFC ) ) )

    48 #define SET_RECEIVER_OBJ( msg, o )    msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] = ( IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] ) ) ? \

    49                                       GET_RECEIVER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x0F ) : GET_RECEIVER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x03 ), \

    50                                       msg[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] = ( TUint8 )( ( o ) & 0x00FF )

    51 #define SET_SENDER_OBJ( msg, o )      msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] = ( IS_DEV_HOST( msg[ ISI_HEADER_OFFSET_SENDERDEVICE ] ) ) ? \

    52                                       GET_SENDER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x0F ) : GET_SENDER_DEV( msg ) | ( ( ( o ) >> 8 ) & 0x03 ), \

    53                                       msg[ ISI_HEADER_OFFSET_SENDEROBJECT ] = ( TUint8 )( ( o ) & 0x00FF )

    54 // Panic code literals

    55 _LIT( KInvalidOffset, "IsiMessage: OFFSET Invalid" );

    56 _LIT( KInvalidValue, "IsiMessage: Invalid Value" );

    57 _LIT( KInvalidSubBlockType, "IsiMessage: SBTYPE Invalid");

    58 _LIT( KInvalidResourceId, "IsiMessage: Invalid ExtendedResourceId");

    59 

    60 // -----------------------------------------------------------------------------

    61 // TIsi::operator=

    62 // -----------------------------------------------------------------------------

    63 EXPORT_C TIsi& TIsi::operator=

    64         ( 

    65         const TIsi&

    66         )

    67     {

    68 

    69     C_TRACE( ( _T( "TIsi::operator=" ) ) );

    70     OstTrace0( TRACE_NORMAL, TISI_OPERATOR, "TIsi::operator=" );

    71 

    72     return ( *this );

    73 

    74     }

    75 

    76 

    77 // -----------------------------------------------------------------------------

    78 // TIsiReceiveC::FindSubBlockOffsetById

    79 // -----------------------------------------------------------------------------

    80 EXPORT_C TInt TIsiReceiveC::FindSubBlockOffsetById 

    81         ( 

    82         const TUint aSbStartOffset,

    83         const TUint aSubblockId,

    84         const TSubBlockType aType,

    85         TUint &aSubBlockOffset

    86         ) const

    87     {

    88 

    89     C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById entering, (sbStart 0x%x, sbId 0x%x, aType %d  )" ), aSbStartOffset, aSubblockId, aType ) );

    90     OstTraceExt3( TRACE_NORMAL, TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById entering;sbStart=%u;sbId=%u;aType=%x;", aSbStartOffset, aSubblockId, ( TUint )&( aType ));   

    91     

    92     TInt finder_offset( aSbStartOffset );

    93     TInt length( iBuffer.Length() );

    94 

    95     // Message has to be divisible by four, when it has any subblocks

    96     TRACE_ASSERT ( length %  4 == 0 ); //Invalid length

    97     TRACE_ASSERT ( finder_offset % 4 == 0 ); //Invalid offset

    98 

    99     TUint subblock_id( 0 );

   100     TUint subblock_len( 0 );

   101     TBool found( EFalse );

   102     TInt retval( KErrNotFound );

   103 

   104     if( ( length - KMinSbLength ) < finder_offset )

   105         {

   106             C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById used with msg which doesn't contains any subblocks, (retval %d)" ), retval ) );

   107             OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById used with msg which doesn't contains any subblocks;retval=%d", retval );

   108         }

   109     else

   110         {        

   111         do

   112             {

   113             switch( aType )

   114                 {

   115                 case EIsiSubBlockTypeId8Len8:

   116                    {

   117                   subblock_id = this->Get8bit( finder_offset );

   118                   subblock_len = this->Get8bit( finder_offset + 1 );

   119                   break;

   120                   }

   121                 case EIsiSubBlockTypeId8Len16:

   122                     {

   123                     subblock_id = this->Get8bit( finder_offset );

   124                     subblock_len = this->Get16bit( finder_offset + 2 );

   125                     break;

   126                     }

   127                 case EIsiSubBlockTypeId16Len8:

   128                     {

   129                     subblock_id = this->Get16bit( finder_offset );

   130                     subblock_len = this->Get8bit( finder_offset + 2 );

   131                     break;

   132                     }

   133                 case EIsiSubBlockTypeId16Len16:

   134                     {

   135                     subblock_id = this->Get16bit( finder_offset );

   136                     subblock_len = this->Get16bit( finder_offset + 2 );

   137                     break;

   138                     }

   139                 case EIsiSubBlockTypeId8Len32:

   140                     {

   141                     subblock_id = this->Get8bit( finder_offset );

   142                     subblock_len = this->Get32bit( finder_offset + 4 );

   143                     break;

   144                     }

   145                 default:

   146                     {

   147                     User::Panic( KInvalidSubBlockType, KErrArgument );

   148                     break;

   149                     }

   150                 }

   151 

   152             if ( subblock_len == 0 )

   153                 {

   154                 C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById has found corrupted data, sb_len = 0 ->stop searching!" ) ) );           

   155                 OstTrace0( TRACE_NORMAL, DUP2_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById has found corrupted data, sb_len = 0 ->stop searching!" );

   156                 found = ETrue;

   157                 retval = KErrNotFound;

   158                 }

   159 

   160             if ( aSubblockId == subblock_id )

   161                 {

   162                 found = ETrue;

   163                 aSubBlockOffset = finder_offset;

   164                 retval = KErrNone;

   165                 }

   166             else

   167                 {

   168                 finder_offset+= subblock_len;

   169                 }

   170             } while ( !found && ( finder_offset + KMinSbLength <= length ) );

   171         }

   172 

   173     C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetById returning, aSbStartOffset = 0x%x" ), finder_offset ) );

   174     OstTrace1( TRACE_NORMAL, DUP3_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYID, "TIsiReceiveC::FindSubBlockOffsetById - return found sbStartOffset=%d", finder_offset );   

   175 

   176     return retval;

   177    

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // TIsiReceiveC::FindSubBlockOffsetByIndex

   182 // -----------------------------------------------------------------------------

   183 EXPORT_C TInt TIsiReceiveC::FindSubBlockOffsetByIndex

   184         ( 

   185         const TUint aSbStartOffset,

   186         const TUint aSubblockIndex,

   187         const TSubBlockType aType,

   188         TUint &aSubBlockOffset

   189         ) const

   190     { 

   191 

   192     C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex entering, (sbStart 0x%x, sbIndex 0x%x, aType %d  )" ), aSbStartOffset, aSubblockIndex, aType ) );

   193     OstTraceExt3( TRACE_NORMAL, TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex;sbStart=%u;subblockIndex=%u;aType=%x;", aSbStartOffset, aSubblockIndex, ( TUint )&( aType ) );

   194 

   195     TInt finder_offset( aSbStartOffset );

   196     TInt length( iBuffer.Length() );

   197     

   198     // Message has to be divisible by four, when it has any subblocks

   199     TRACE_ASSERT ( length % 4 == 0 ); //Invalid length

   200     TRACE_ASSERT ( finder_offset % 4 == 0 ); // Invalid offset

   201 

   202     TUint subblock_len ( 0 );

   203     TUint index ( 0 );

   204     TBool found ( EFalse );

   205     TInt retval( KErrNotFound );

   206 

   207     if( ( length - KMinSbLength ) < finder_offset )

   208         {

   209         C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex used with msg which doesn't contains any subblocks, (retval %d)" ), retval ) );     

   210         OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex used with msg which doesn't contains any subblocks;retval=%d", retval );

   211         }

   212     else

   213         {        

   214         do

   215             {

   216             index++;

   217             switch( aType )

   218             {

   219             case EIsiSubBlockTypeId8Len8:

   220                 {

   221                 subblock_len = this->Get8bit( finder_offset + 1 );

   222                 break;

   223                 }

   224             case EIsiSubBlockTypeId8Len16:

   225                 {

   226                 subblock_len = this->Get16bit( finder_offset + 2 );

   227                 break;

   228                 }

   229             case EIsiSubBlockTypeId16Len8:

   230                 {

   231                 subblock_len = this->Get8bit( finder_offset + 2 );

   232                 break;

   233                 }

   234             case EIsiSubBlockTypeId16Len16:

   235                 {

   236                 subblock_len = this->Get16bit( finder_offset + 2 );

   237                 break;

   238                 }

   239             case EIsiSubBlockTypeId8Len32:

   240                 {

   241                 subblock_len = this->Get32bit( finder_offset + 4 );

   242                 break;

   243                 }

   244             default:

   245                 {

   246                 User::Panic( KInvalidSubBlockType, KErrArgument );

   247                 break;

   248                 }

   249             }

   250 

   251         if ( subblock_len == 0 )

   252             {

   253             C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex has found corrupted data, sb_len = 0 ->stop searching" ) ) );           

   254             OstTrace0( TRACE_NORMAL, DUP2_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex has found corrupted data, sb_len = 0 ->stop searching!" );

   255             found = ETrue;

   256             retval = KErrNotFound;

   257             }

   258 

   259         if( index == aSubblockIndex )

   260             {

   261             found = ETrue;

   262             aSubBlockOffset = finder_offset;

   263             retval = KErrNone;

   264             }

   265         else

   266             {

   267             finder_offset+=subblock_len;

   268             }

   269         } while( !found && ( index <= aSubblockIndex ) && (finder_offset + KMinSbLength <= length ) );

   270     }

   271 

   272     C_TRACE( ( _L ( "TIsiReceiveC::FindSubblockOffsetByIndex returning, aSbStartOffset = 0x%x" ), finder_offset ) );

   273     OstTrace1( TRACE_NORMAL, DUP3_TISIRECEIVEC_FINDSUBBLOCKOFFSETBYINDEX, "TIsiReceiveC::FindSubBlockOffsetByIndex - return found sbStartOffset=%d", finder_offset );

   274 

   275     return retval;

   276     

   277     }

   278 

   279 // -----------------------------------------------------------------------------

   280 // TIsiReceiveC::Get16bit

   281 // -----------------------------------------------------------------------------

   282 EXPORT_C TUint16 TIsiReceiveC::Get16bit

   283         (

   284         const TUint aOffset 

   285         ) const

   286     {

   287 

   288     C_TRACE( ( _L ( "TIsiReceiveC::Get16bit entering, aOffset 0x%x" ), aOffset ) );

   289     OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET16BIT, "TIsiReceiveC::Get16bit - enter;aOffset=%u", aOffset );

   290 

   291     ASSERT_RESET_ALWAYS( ((iBuffer.Length() - 1) > aOffset), KInvalidOffset, KErrOverflow );

   292     TRACE_ASSERT ( aOffset % 2 == 0 ); //Invalid offset

   293 

   294     TUint16 retval( KSixteenBitZero );

   295     TUint16 byte1( KSixteenBitZero );

   296     TUint16 byte2( KSixteenBitZero );

   297 

   298     byte1 = iBuffer[ aOffset ];

   299     byte2 = iBuffer[ aOffset + 1 ];

   300     retval = TUint16( ( byte1 << 8 ) | byte2 );  

   301    

   302     C_TRACE( ( _L ( "TIsiReceiveC::Get16bit - return, return 16bit value = 0x%x" ), retval ) );

   303    OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET16BIT, "TIsiReceiveC::Get16bit - return retval=%hu", retval );

   304    

   305     return retval;

   306 

   307     }

   308 

   309 // -----------------------------------------------------------------------------

   310 // TIsiReceiveC::Get32bit

   311 // -----------------------------------------------------------------------------

   312 EXPORT_C TUint32 TIsiReceiveC::Get32bit

   313         (

   314         const TUint aOffset

   315         ) const

   316     {

   317 

   318     C_TRACE( ( _L ( "TIsiReceiveC::Get32bit entering, aOffset = 0x%x" ) , aOffset ) );

   319     OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET32BIT, "TIsiReceiveC::Get32bit - enter;aOffset=%u", aOffset );

   320     

   321 

   322     ASSERT_RESET_ALWAYS( ( iBuffer.Length() - 3 > aOffset ), KInvalidOffset, KErrOverflow );

   323     TRACE_ASSERT ( aOffset % 4 == 0 ); // Invalid offset

   324 

   325     TUint32 retval( KThirtytwoBitZero );

   326     TUint32 byte1( KThirtytwoBitZero );

   327     TUint32 byte2( KThirtytwoBitZero );

   328     TUint32 byte3( KThirtytwoBitZero );

   329     TUint32 byte4( KThirtytwoBitZero );

   330     

   331     byte1 = iBuffer[ aOffset ];

   332     byte2 = iBuffer[ aOffset + 1 ];

   333     byte3 = iBuffer[ aOffset + 2 ];

   334     byte4 = iBuffer[ aOffset + 3 ];

   335 

   336     retval = TUint32( byte1 << 24 );

   337     retval = TUint32( retval | ( byte2 << 16 ));

   338     retval = TUint32( retval | ( byte3 << 8 ));

   339     retval = TUint32( retval | byte4 );

   340 

   341     C_TRACE( ( _L ( "TIsiReceiveC::Get32bit - return, Return 32bit value = 0x%x" ), retval ) );

   342     OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET32BIT, "TIsiReceiveC::Get32bit - return retval=%d", retval );

   343 

   344     return retval;

   345 

   346     }

   347 

   348 // -----------------------------------------------------------------------------

   349 // TIsiReceiveC::Get8bit

   350 // -----------------------------------------------------------------------------

   351 EXPORT_C TUint8 TIsiReceiveC::Get8bit

   352         (

   353         const TUint aOffset 

   354         ) const

   355     {

   356 

   357     C_TRACE( ( _L ( "TIsiReceiveC::Get8bit entering, aOffset = 0x%x" ) , aOffset ) );

   358     OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GET8BIT, "TIsiReceiveC::Get8bit - enter;aOffset=%u", aOffset );

   359     

   360 

   361     ASSERT_RESET_ALWAYS( ( iBuffer.Length() > aOffset ), KInvalidOffset, KErrOverflow );

   362 

   363     C_TRACE( ( _L ( "TIsiReceiveC::Get8bit - return, return value = 0x%x" ) , iBuffer[aOffset] ) );

   364     OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GET8BIT, "TIsiReceiveC::Get8bit - return iBuffer[aOffset]=%hhu", iBuffer[aOffset] );

   365     

   366     return iBuffer[ aOffset ];

   367 

   368     }

   369 

   370 // -----------------------------------------------------------------------------

   371 // TIsiReceiveC::GetData

   372 // -----------------------------------------------------------------------------

   373 EXPORT_C const TPtrC8 TIsiReceiveC::GetData

   374         (

   375         const TUint aOffset,

   376         const TInt aLength

   377         ) const

   378     {

   379 

   380     C_TRACE( ( _L ( "TIsiReceiveC::GetData entering, aOffset = 0x%x" ), aOffset ) );

   381     OstTrace1( TRACE_NORMAL, TISIRECEIVEC_GETDATA, "TIsiReceiveC::GetData - enter;aOffset=%u", aOffset );

   382     

   383     ASSERT_RESET_ALWAYS( ( ( iBuffer.Length() - aLength ) >= aOffset), KInvalidOffset, KErrOverflow );

   384     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= aLength ), KInvalidOffset, KErrOverflow );

   385 

   386     TRACE_ASSERT ( aLength > 0 ); // Invalid length, should be >0

   387 

   388     C_TRACE( ( _L ( "TIsiReceiveC::GetData - return, aOffset = 0x%x, aLength = 0x%x" ), aOffset, aLength ) );

   389     OstTraceExt2( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETDATA, "TIsiReceiveC::GetData - return aOffset=%u;aLength=%u", aOffset, aLength );

   390     

   391     return TPtrC8( iBuffer.Mid( aOffset, aLength ) );

   392 

   393     }

   394 

   395 // -----------------------------------------------------------------------------

   396 // TIsiReceiveC::TIsiReceiveC

   397 // -----------------------------------------------------------------------------

   398 EXPORT_C TIsiReceiveC::TIsiReceiveC

   399         (

   400         const TDesC8& aBuf

   401         )

   402         :TIsi(),

   403         iBuffer( aBuf )

   404     {

   405     C_TRACE( ( _T ( "TIsiReceiveC::TIsiReceiveC constructor" ) ) );

   406     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_TISIRECEIVEC, "TIsiReceiveC::TIsiReceiveC constructor" );

   407     

   408 

   409     }

   410 

   411 // -----------------------------------------------------------------------------

   412 // TIsiReceiveC::GetBuffer

   413 // -----------------------------------------------------------------------------

   414 EXPORT_C const TPtrC8 TIsiReceiveC::GetBuffer

   415         () const

   416     {

   417     C_TRACE( ( _T ( "TIsiReceiveC::GetBuffer" ) ) );

   418     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETBUFFER, "TIsiReceiveC::GetBuffer" );

   419     

   420     return iBuffer;

   421 

   422     }

   423 

   424 // -----------------------------------------------------------------------------

   425 // TIsiReceiveC::GetReceiverDevice

   426 // -----------------------------------------------------------------------------

   427 EXPORT_C TUint8 TIsiReceiveC::GetReceiverDevice

   428         () const

   429     {

   430 

   431     C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverDevice - entering" ) ) );

   432     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETRECEIVERDEVICE, "TIsiReceiveC::GetReceiverDevice - enter" );

   433     

   434     ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow);

   435 

   436     TUint8 receiverDevice = GET_RECEIVER_DEV(iBuffer);

   437 

   438     C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverDevice - return, receiverDevice = 0x%x" ), receiverDevice ) );

   439     OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETRECEIVERDEVICE, "TIsiReceiveC::GetReceiverDevice - return receiverDevice=%hhu", receiverDevice );

   440     

   441     return receiverDevice;

   442 

   443     }

   444 

   445 // -----------------------------------------------------------------------------

   446 // TIsiReceiveC::GetSenderDevice

   447 // -----------------------------------------------------------------------------

   448 EXPORT_C TUint8 TIsiReceiveC::GetSenderDevice

   449         () const

   450     {

   451 

   452     C_TRACE( ( _T ( "TIsiReceiveC::GetSenderDevice - entering" ) ) );

   453     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETSENDERDEVICE, "TIsiReceiveC::GetSenderDevice - enter" );

   454     

   455     ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow );

   456 

   457     TUint8 senderDevice = GET_SENDER_DEV(iBuffer);

   458                 

   459     C_TRACE( ( _T ( "TIsiReceiveC::GetSenderDevice - return, senderDevice = 0x%x" ), senderDevice ) );

   460     OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETSENDERDEVICE, "TIsiReceiveC::GetSenderDevice - return senderDevice=%hhu", senderDevice );

   461     

   462     return senderDevice;

   463 

   464     }

   465 

   466 // -----------------------------------------------------------------------------

   467 // TIsiReceiveC::GetReceiverObject

   468 // -----------------------------------------------------------------------------

   469 EXPORT_C TUint16 TIsiReceiveC::GetReceiverObject

   470         () const

   471     {

   472 

   473     C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverObject - entering" ) ) );

   474     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETRECEIVEROBJECT, "TIsiReceiveC::GetReceiverObject - enter" );

   475     

   476     ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidOffset, KErrOverflow );

   477 

   478     TUint16 receiverObject = static_cast<TUint16>GET_RECEIVER_OBJ(iBuffer);

   479                 

   480     C_TRACE( ( _T ( "TIsiReceiveC::GetReceiverObject - return, receiverObject = 0x%x" ), receiverObject ) );

   481     OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETRECEIVEROBJECT, "TIsiReceiveC::GetReceiverObject - return receiverObject=%hu", receiverObject );

   482     

   483     return receiverObject;

   484 

   485     }

   486 

   487 

   488 // -----------------------------------------------------------------------------

   489 // TIsiReceiveC::GetSenderObject

   490 // -----------------------------------------------------------------------------

   491 EXPORT_C TUint16 TIsiReceiveC::GetSenderObject

   492         () const

   493     {

   494 

   495     C_TRACE( ( _T ( "TIsiReceiveC::GetSenderObject - entering" ) ) );

   496     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETSENDEROBJECT, "TIsiReceiveC::GetSenderObject - enter" );

   497     

   498     ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID),  KInvalidOffset, KErrOverflow );

   499 

   500     TUint16 senderObject = static_cast<TUint16>GET_SENDER_OBJ( iBuffer );

   501 

   502     C_TRACE( ( _T ( "TIsiReceiveC::GetSenderObject - return, senderObject = 0x%x" ), senderObject ) );

   503     OstTraceExt1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETSENDEROBJECT, "TIsiReceiveC::GetSenderObject - return senderObject=%hu", senderObject );

   504     

   505     return senderObject;

   506 

   507     }

   508 

   509 // -----------------------------------------------------------------------------

   510 // TIsiReceiveC::GetExtendedResourceId

   511 // -----------------------------------------------------------------------------

   512 EXPORT_C TUint32 TIsiReceiveC::GetExtendedResourceId

   513         () const

   514     {

   515 

   516     C_TRACE( ( _T ( "TIsiReceiveC::GetExtendedResourceId - entering" ) ) );

   517     OstTrace0( TRACE_NORMAL, TISIRECEIVEC_GETEXTENDEDRESOURCEID, "TIsiReceiveC::GetExtendedResourceId - enter" );

   518     

   519     TUint32 extendedResourceId(0x00000000);

   520 

   521     //Check that extended resource id available and not reading over the buffer

   522     ASSERT_RESET_ALWAYS( (iBuffer[ISI_HEADER_OFFSET_RESOURCEID] == PN_PREFIX), KInvalidResourceId, KErrOverflow );

   523     ASSERT_RESET_ALWAYS( (iBuffer.Length() > ISI_HEADER_OFFSET_MESSAGEID), KInvalidResourceId, KErrOverflow );

   524 

   525     TUint8 temp(iBuffer[ ISI_HEADER_OFFSET_SUBTYPE ]);

   526     TUint32 subType = static_cast<TUint32>( temp << 16 );

   527     TUint32 type = static_cast<TUint32>( iBuffer[ ISI_HEADER_OFFSET_TYPE ] << 8 );

   528                                                                   

   529     extendedResourceId = static_cast<TUint32>(PN_PREFIX) | subType | type ;

   530 

   531     C_TRACE( ( _T ( "TIsiReceiveC::GetExtendedResourceId - return, extendedResourceId = 0x%x" ), extendedResourceId ) );

   532     OstTrace1( TRACE_NORMAL, DUP1_TISIRECEIVEC_GETEXTENDEDRESOURCEID, "TIsiReceiveC::GetExtendedResourceId - return extendedResourceId=%u", extendedResourceId );

   533     

   534     return extendedResourceId;

   535 

   536     }

   537 

   538 //-------------------------------------------------------------------------------

   539 // TIsiSend::Complete 

   540 // -----------------------------------------------------------------------------

   541 EXPORT_C TDes8& TIsiSend::Complete

   542         (

   543         // None

   544         )

   545     {

   546 

   547     C_TRACE( ( _L ( "TIsiSend::Complete entering" ) ) );

   548     OstTrace0( TRACE_NORMAL, TISISEND_COMPLETE, "TIsiSend::Complete - enter" );

   549     

   550     // Set msg length in hex.

   551     TUint16 length( TUint16( iBuffer.Length() - KMessageHeaderLength ) ); 

   552     TUint16 calcFinalLength( TUint16( iFinalLength - KMessageHeaderLength ) );

   553 

   554     C_TRACE( ( _T ( "TIsiSend::Complete, length: 0x%x, calcfinallength: 0x%x" ), length, calcFinalLength ) );

   555     OstTraceExt2( TRACE_NORMAL, DUP1_TISISEND_COMPLETE, "TIsiSend::Complete;length=%hu;calcFinalLength=%hu", length, calcFinalLength );

   556     

   557     #if defined( __WINS__ ) || defined( __WINSCW__ )

   558         {

   559          if( iFinalLength == 0 )    // TIsiSend alternative constructor used

   560             {

   561                 TUint8 byte1 = ( TUint8 )( ( length & 0xff00 ) >> 8 );

   562                 TUint8 byte2 = ( TUint8 )( length & 0x00ff );        

   563                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH, byte1 );        // BE

   564                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH + 1, byte2 );    // BE

   565             }

   566          else

   567             {

   568                 TUint8 byte1 = ( TUint8 )( ( calcFinalLength & 0xff00 ) >> 8 );

   569                 TUint8 byte2 = ( TUint8 )( calcFinalLength & 0x00ff );        

   570                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH, byte1 );        // BE

   571                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH + 1, byte2 );    // BE               

   572                 iBuffer.SetLength( iFinalLength );

   573             }

   574         }

   575     #else

   576         {

   577          if( iFinalLength == 0 )    // TIsiSend alternative constructor used

   578                 {

   579                 TUint8 byte1 = ( TUint8 )( ( length & 0xff00 ) >> 8 );

   580                 TUint8 byte2 = ( TUint8 )( length & 0x00ff );        

   581                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH, byte2 );        // LE

   582                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH + 1, byte1 );    // LE

   583                 }

   584             else

   585                 {

   586                 TUint8 byte1 = ( TUint8 )( ( calcFinalLength & 0xff00 ) >> 8 );

   587                 TUint8 byte2 = ( TUint8 )( calcFinalLength & 0x00ff );        

   588                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH, byte2 );        // LE

   589                 this->Set8bit( ISI_HEADER_OFFSET_LENGTH + 1, byte1 );    // LE               

   590                 iBuffer.SetLength( iFinalLength );

   591                 }

   592         }

   593     #endif    

   594 

   595     C_TRACE( ( _T ( "TIsiSend::Complete, byte2: 0x%x, byte1: 0x%x" ), iBuffer[5], iBuffer[4] ) );

   596     OstTraceExt2( TRACE_NORMAL, DUP2_TISISEND_COMPLETE, "TIsiSend::Complete;byte2=%hhu;byte1=%hhu", iBuffer[5], iBuffer[4] );

   597     

   598     C_TRACE( ( _L ( "TIsiSend::Complete - return, buffer length = 0x%x, iFinalLength = 0x%x" ), length, iFinalLength ) );

   599     OstTraceExt2( TRACE_NORMAL, DUP3_TISISEND_COMPLETE, "TIsiSend::Complete - return buffer length=%hu;iFinalLength=%u", length, iFinalLength );

   600     

   601     return iBuffer;

   602 

   603     }

   604 

   605 // -----------------------------------------------------------------------------

   606 // TIsiSend::CopyData

   607 // -----------------------------------------------------------------------------

   608 EXPORT_C void TIsiSend::CopyData

   609         (

   610         const TUint aOffset,

   611         const TDesC8& aData

   612         )

   613     {

   614 

   615     C_TRACE( ( _L ( "TIsiSend::CopyData entering, offset = 0x%x" ), aOffset ) );

   616     OstTrace1( TRACE_NORMAL, TISISEND_COPYDATA, "TIsiSend::CopyData - enter;aOffset=%u", aOffset );

   617 

   618     TInt length( aData.Length() );

   619        

   620     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= aOffset + length ), KInvalidOffset, KErrOverflow );

   621     

   622     if( iBuffer.Length() <= aOffset ) iBuffer.SetLength( aOffset + length );     

   623   

   624     ASSERT_RESET_ALWAYS( ( ( iBuffer.Length() - length ) >= aOffset ), KInvalidOffset, KErrOverflow );

   625     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= length ), KInvalidOffset, KErrOverflow );

   626        

   627     TRACE_ASSERT ( length > 0); // Invalid descriptor, buffer underflow 

   628     

   629     // Add byte by byte starting from offset place until the whole data is set.

   630     for( TInt i( 0 ); i < length; i++ )

   631         {

   632         this->Set8bit( ( aOffset + i ), aData.Ptr()[ i ] );

   633         }

   634 

   635     OstTraceExt2( TRACE_NORMAL, DUP1_TISISEND_COPYDATA, "TIsiSend::CopyData - return aOffset=%u;length=%d", aOffset, length );

   636     C_TRACE( ( _L ( "TIsiSend::CopyData - return, offset = 0x%x, data length = 0x%x " ), aOffset, length ) );

   637     

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // TIsiSend::TIsiSend

   642 // -----------------------------------------------------------------------------

   643 EXPORT_C TIsiSend::TIsiSend

   644         (

   645         TDes8& aBuf,

   646         const TUint aLength

   647         )

   648         :TIsi(),

   649         iBuffer( aBuf ),

   650         iFinalLength( aLength ) // this should be same as msg length

   651     {

   652 

   653     C_TRACE( ( _L ( "TIsiSend::TIsiSend entering, aLength = 0x%x " ), aLength ) ) ;

   654     OstTrace1( TRACE_NORMAL, TISISEND_TISISEND, "TIsiSend::TIsiSend - enter;aLength=%u", aLength );

   655     

   656     // Length check

   657 	ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= aLength ), KInvalidOffset, KErrOverflow );

   658 

   659     // Set the message to contain zeros to it's length.

   660     iBuffer.FillZ( aLength );

   661 

   662     // Set the length to zero.

   663     iBuffer.Zero();

   664     

   665     C_TRACE( ( _L ( "TIsiSend::TIsiSend - return. iFinalLength = 0x%x" ), iFinalLength ) ) ;

   666     OstTrace1( TRACE_NORMAL, DUP1_TISISEND_TISISEND, "TIsiSend::TIsiSend - return iFinalLength=%u", iFinalLength );

   667     

   668     }

   669 

   670 // -----------------------------------------------------------------------------

   671 // TIsiSend::TIsiSend alternative constructor

   672 // -----------------------------------------------------------------------------

   673 EXPORT_C TIsiSend::TIsiSend

   674         (

   675         TDes8& aBuf

   676         )

   677         :TIsi(),

   678         iBuffer( aBuf ),

   679         iFinalLength( 0 )

   680     {

   681 

   682     C_TRACE( ( _L ( "TIsiSend::TIsiSend constructor without length, entering" ) ) );

   683     OstTrace0( TRACE_NORMAL, DUP2_TISISEND_TISISEND, "TIsiSend::TIsiSend constructor without length - enter" );

   684     

   685     // Set the message to contain zeros to it's max length.

   686     iBuffer.FillZ( iBuffer.MaxLength() );

   687 

   688     // Set the length to zero.

   689     iBuffer.Zero();

   690     

   691     C_TRACE( ( _L ( "TIsiSend::TIsiSend constructor without length - return. iFinalLength = 0x%x" ), iFinalLength ) ) ;

   692     OstTrace1( TRACE_NORMAL, DUP3_TISISEND_TISISEND, "TIsiSend::TIsiSend constructor without length - return iFinalLength=%u", iFinalLength );

   693     

   694     }

   695 

   696 // -----------------------------------------------------------------------------

   697 // TIsiSend::Set16bit

   698 // -----------------------------------------------------------------------------

   699 EXPORT_C void TIsiSend::Set16bit

   700         (

   701         const TUint aOffset,

   702         const TUint16 aData

   703         )

   704     {

   705     C_TRACE( ( _L ( "TIsiSend::Set16bit entering, offset = 0x%x, aData = 0x%x" ), aOffset, aData ) );

   706     OstTraceExt2( TRACE_NORMAL, TISISEND_SET16BIT, "TIsiSend::Set16bit - enter;aOffset=%u;aData=%hu", aOffset, aData );

   707     

   708     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= aOffset + 2 ), KInvalidOffset, KErrOverflow );

   709     if( iBuffer.Length() <= aOffset ) iBuffer.SetLength( aOffset + 2 ); 

   710     

   711     ASSERT_RESET_ALWAYS( ( iBuffer.Length() -1 >= aOffset ), KInvalidOffset, KErrOverflow );

   712     

   713     TRACE_ASSERT ( aOffset % 2 == 0 ); // Invalid offset

   714 

   715     TUint8 byte1 = ( TUint8 )( ( aData & 0xff00 ) >> 8 );

   716     TUint8 byte2 = ( TUint8 )( aData & 0x00ff );

   717 

   718     this->Set8bit( aOffset, byte1 );     

   719     this->Set8bit( aOffset + 1, byte2 ); 

   720 

   721     C_TRACE( ( _L ( "TIsiSend::Set16bit - return, aOffset = 0x%x, aData = 0x%x" ), aOffset, aData ) );

   722     OstTraceExt2( TRACE_NORMAL, DUP1_TISISEND_SET16BIT, "TIsiSend::Set16bit - return;aOffset=%u;aData=%hu", aOffset, aData );

   723     

   724     }

   725 

   726 // -----------------------------------------------------------------------------

   727 // TIsiSend::Set32bit

   728 // -----------------------------------------------------------------------------

   729 EXPORT_C void TIsiSend::Set32bit

   730         (

   731         const TUint aOffset,

   732         const TUint32 aData

   733         )

   734     {

   735 

   736     C_TRACE( ( _L ( "TIsiSend::Set32bit entering, offset = 0x%x, aData = 0x%x" ), aOffset, aData ) );   

   737     OstTraceExt2( TRACE_NORMAL, TISISEND_SET32BIT, "TIsiSend::Set32bit - enter;aOffset=%u;aData=%hhu", aOffset, ( TUint )( aData ) );

   738         

   739     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= aOffset + 4  ), KInvalidOffset, KErrOverflow );

   740     

   741     if( iBuffer.Length() <= aOffset ) iBuffer.SetLength( aOffset + 4 ); 

   742     

   743     ASSERT_RESET_ALWAYS( ( iBuffer.Length() -3 >= aOffset ), KInvalidOffset, KErrOverflow );

   744     

   745     TRACE_ASSERT ( aOffset % 4 == 0 ); // Invalid offset

   746 

   747     TUint8 byte1 = ( TUint8 )( ( aData & 0xff000000 ) >> 24 );

   748     TUint8 byte2 = ( TUint8 )( ( aData & 0x00ff0000 ) >> 16 );

   749     TUint8 byte3 = ( TUint8 )( ( aData & 0x0000ff00 ) >> 8 );

   750     TUint8 byte4 = ( TUint8 )( aData & 0x000000ff );

   751 

   752     this->Set8bit( aOffset, byte1 );       

   753     this->Set8bit( aOffset + 1, byte2 );  

   754     this->Set8bit( aOffset + 2, byte3 ); 

   755     this->Set8bit( aOffset + 3, byte4 ); 

   756 

   757     C_TRACE( ( _L ( "TIsiSend::Set32bit - return, offset = 0x%x, aData = 0x%x" ), aOffset, aData ) );

   758     OstTraceExt2( TRACE_NORMAL, DUP1_TISISEND_SET32BIT, "TIsiSend::Set32bit - return;aOffset=%u;aData=%hhu", aOffset, ( TUint )( aData ) );

   759     

   760     }

   761 

   762 // -----------------------------------------------------------------------------

   763 // TIsiSend::Set8bit

   764 // -----------------------------------------------------------------------------

   765 EXPORT_C void TIsiSend::Set8bit

   766         (

   767         const TUint aOffset,

   768         const TUint8 aData

   769         )

   770     {

   771 

   772     C_TRACE( ( _L ( "TIsiSend::Set8bit entering, offset = 0x%x, aData = 0x%x" ), aOffset, aData ) );

   773     OstTraceExt2( TRACE_NORMAL, TISISEND_SET8BIT, "TIsiSend::Set8bit - enter;aOffset=%u;aData=%hhu", aOffset, aData );

   774     

   775     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= aOffset + 1 ), KInvalidOffset, KErrOverflow );

   776 

   777     if( iBuffer.Length() <= aOffset ) iBuffer.SetLength( aOffset + 1 );

   778     

   779     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= aOffset ), KInvalidOffset, KErrOverflow );

   780 

   781     iBuffer[ aOffset ] = aData;

   782 

   783     C_TRACE( ( _L ( "TIsiSend::Set8bit - return, offset = 0x%x, aData = 0x%x" ), aOffset, aData ) );

   784     OstTraceExt2( TRACE_NORMAL, DUP1_TISISEND_SET8BIT, "TIsiSend::Set8bit - return;aOffset=%u;aData=%hhu", aOffset, aData );

   785     

   786     }

   787 

   788 // -----------------------------------------------------------------------------

   789 // TIsiSend::SetReceiverDevice

   790 // -----------------------------------------------------------------------------

   791 EXPORT_C void TIsiSend::SetReceiverDevice

   792         (

   793         const TUint8 aReceiverDevice

   794         )

   795     {

   796 

   797     C_TRACE( ( _T ( "TIsiSend::SetReceiverDevice entering - receiverDevice = 0x%x" ), aReceiverDevice ) );

   798     OstTraceExt1( TRACE_NORMAL, TISISEND_SETRECEIVERDEVICE, "TIsiSend::SetReceiverDevice - enter;aReceiverDevice=%hhu", aReceiverDevice );

   799     

   800     //Check buffer length and given value

   801     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= ISI_HEADER_OFFSET_MESSAGEID ), KInvalidOffset, KErrOverflow );

   802 

   803     if( iBuffer.Length() <= ISI_HEADER_OFFSET_RECEIVERDEVICE ) iBuffer.SetLength( ISI_HEADER_OFFSET_RECEIVERDEVICE + 1 );

   804     

   805     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= ISI_HEADER_OFFSET_RECEIVERDEVICE ), KInvalidOffset, KErrOverflow );

   806 

   807     iBuffer[ISI_HEADER_OFFSET_RECEIVERDEVICE] = SET_RECEIVER_DEV(iBuffer, aReceiverDevice);

   808         

   809     C_TRACE( ( _T ( "TIsiSend::SetReceiverDevice return - receiverDevice = 0x%x "), iBuffer[ISI_HEADER_OFFSET_RECEIVERDEVICE] ) );

   810     OstTraceExt1( TRACE_NORMAL, DUP1_TISISEND_SETRECEIVERDEVICE, "TIsiSend::SetReceiverDevice - return; receiverDevice=%hhu", iBuffer[ISI_HEADER_OFFSET_RECEIVERDEVICE] );

   811     

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // TIsiSend::SetSenderDevice

   816 // -----------------------------------------------------------------------------

   817 EXPORT_C void TIsiSend::SetSenderDevice

   818         (

   819         const TUint8 aSenderDevice

   820         )

   821     {

   822 

   823     C_TRACE( ( _T ( "TIsiSend::SetSenderDevice entering - senderDevice = 0x%x" ), aSenderDevice ) );

   824     OstTraceExt1( TRACE_NORMAL, TISISEND_SETSENDERDEVICE, "TIsiSend::SetSenderDevice - enter;aSenderDevice=%hhu", aSenderDevice );

   825     

   826     //Check buffer length and given value

   827     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= ISI_HEADER_OFFSET_MESSAGEID ), KInvalidOffset, KErrOverflow );

   828 

   829     if( iBuffer.Length() <= ISI_HEADER_OFFSET_SENDERDEVICE ) iBuffer.SetLength( ISI_HEADER_OFFSET_SENDERDEVICE + 1 );

   830     

   831     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= ISI_HEADER_OFFSET_SENDERDEVICE ), KInvalidOffset, KErrOverflow );

   832 

   833     iBuffer[ISI_HEADER_OFFSET_SENDERDEVICE] = SET_SENDER_DEV( iBuffer, aSenderDevice );

   834         

   835     C_TRACE( ( _T ( "TIsiSend::SetSenderDevice return - senderDevice = 0x%x "),  iBuffer[ISI_HEADER_OFFSET_SENDERDEVICE] ) );        

   836     OstTraceExt1( TRACE_NORMAL, DUP1_TISISEND_SETSENDERDEVICE, "TIsiSend::SetSenderDevice - return;senderDevice=%hhu", iBuffer[ISI_HEADER_OFFSET_SENDERDEVICE] );

   837 

   838     }

   839 

   840 // -----------------------------------------------------------------------------

   841 // TIsiSend::SetReceiverObject

   842 // -----------------------------------------------------------------------------

   843 EXPORT_C void TIsiSend::SetReceiverObject

   844         ( 

   845         const TUint16 aReceiverObject

   846         )

   847     {

   848 

   849     C_TRACE( ( _T ( "TIsiSend::SetReceiverObject entering- receiverObject= 0x%x" ), aReceiverObject ) );

   850     OstTraceExt1( TRACE_NORMAL, TISISEND_SETRECEIVEROBJECT, "TIsiSend::SetReceiverObject - enter;aReceiverObject=%hu", aReceiverObject );

   851     

   852     // Check buffer length and given value

   853     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= ISI_HEADER_OFFSET_MESSAGEID ), KInvalidOffset, KErrOverflow );

   854 

   855     ASSERT_RESET_ALWAYS( ( aReceiverObject < 0x3FF ), KInvalidValue, KErrOverflow );

   856 

   857     if( iBuffer.Length() <= ISI_HEADER_OFFSET_RECEIVEROBJECT ) iBuffer.SetLength( ISI_HEADER_OFFSET_RECEIVEROBJECT + 1 );

   858     

   859     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= ISI_HEADER_OFFSET_RECEIVEROBJECT ), KInvalidOffset, KErrOverflow );

   860               

   861     SET_RECEIVER_OBJ(iBuffer, aReceiverObject);

   862 

   863     C_TRACE( ( _T ( "TIsiSend::SetReceiverObject - set receiverDevice = 0x%x "), iBuffer[ISI_HEADER_OFFSET_RECEIVERDEVICE] ) );    

   864     OstTraceExt1( TRACE_NORMAL, DUP1_TISISEND_SETRECEIVEROBJECT, "TIsiSend::SetReceiverObject - set receiverDevice;receiverDevice=%hhu", iBuffer[ISI_HEADER_OFFSET_RECEIVERDEVICE] );

   865 

   866     C_TRACE( ( _T ( "TIsiSend::SetReceiverObject return - receiverObject = 0x%x "), iBuffer[ISI_HEADER_OFFSET_RECEIVEROBJECT] ) );

   867     OstTraceExt1( TRACE_NORMAL, DUP2_TISISEND_SETRECEIVEROBJECT, "TIsiSend::SetReceiverObject - return;receiverObject=%hhu", iBuffer[ISI_HEADER_OFFSET_RECEIVEROBJECT] );

   868 

   869     }

   870 

   871 // -----------------------------------------------------------------------------

   872 // TIsiSend::SetSenderObject

   873 // -----------------------------------------------------------------------------

   874 EXPORT_C void TIsiSend::SetSenderObject

   875         ( 

   876         const TUint16 aSenderObject

   877         )

   878     {

   879 

   880     C_TRACE( ( _T ( "TIsiSend::SetSenderObject entering- senderObject= 0x%x" ), aSenderObject ) );

   881     OstTraceExt1( TRACE_NORMAL, TISISEND_SETSENDEROBJECT, "TIsiSend::SetSenderObject - enter;aSenderObject=%hhx", aSenderObject );

   882     

   883     // Check buffer length and given value

   884     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= ISI_HEADER_OFFSET_MESSAGEID ), KInvalidOffset, KErrOverflow );

   885     ASSERT_RESET_ALWAYS( ( aSenderObject < 0x3FF ), KInvalidValue, KErrOverflow );

   886 

   887     if( iBuffer.Length() <= ISI_HEADER_OFFSET_SENDEROBJECT ) iBuffer.SetLength( ISI_HEADER_OFFSET_SENDEROBJECT + 1 );

   888     

   889     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= ISI_HEADER_OFFSET_SENDEROBJECT ), KInvalidOffset, KErrOverflow );

   890 

   891     SET_SENDER_OBJ(iBuffer, aSenderObject);

   892 

   893     C_TRACE( ( _T ( "TIsiSend::SetSenderObject -  senderDevice = 0x%x" ), iBuffer[ISI_HEADER_OFFSET_SENDERDEVICE] ) );

   894     OstTraceExt1( TRACE_NORMAL, DUP1_TISISEND_SETSENDEROBJECT, "TIsiSend::SetSenderObject - senderDevice;senderDevice=%hhx", iBuffer[ISI_HEADER_OFFSET_SENDERDEVICE] );

   895 

   896     C_TRACE( ( _T ( "TIsiSend::SetSenderObject return - senderObject = 0x%x" ), iBuffer[ISI_HEADER_OFFSET_SENDEROBJECT] ) );        

   897     OstTraceExt1( TRACE_NORMAL, DUP2_TISISEND_SETSENDEROBJECT, "TIsiSend::SetSenderObject - return;senderObject=%hhx", iBuffer[ISI_HEADER_OFFSET_SENDEROBJECT] );

   898     

   899 

   900     }

   901 

   902 // -----------------------------------------------------------------------------

   903 // TIsiSend::SetExtendedResourceId

   904 // -----------------------------------------------------------------------------

   905 EXPORT_C void TIsiSend::SetExtendedResourceId

   906         (

   907         const TUint32 aExtendedResourceId

   908         )

   909     {

   910 

   911     C_TRACE( ( _T ( "TIsiSend::SetExtendedResourceId entering - extendedResourceId = 0x%x" ), aExtendedResourceId ) );

   912     OstTrace1( TRACE_NORMAL, TISISEND_SETEXTENDEDRESOURCEID, "TIsiSend::SetExtendedResourceId - enter;aExtendedResourceId=%u", aExtendedResourceId );

   913     

   914     TUint8 prefix( aExtendedResourceId & 0xFF );

   915                            

   916     //Check that extended resource id available and not reading over the buffer

   917     ASSERT_RESET_ALWAYS( ( iBuffer.MaxLength() >= ISI_HEADER_OFFSET_SUBTYPE + 1 ), KInvalidOffset, KErrOverflow );

   918     ASSERT_RESET_ALWAYS( ( aExtendedResourceId < 0xFFFFFF ), KInvalidResourceId, KErrOverflow );

   919     ASSERT_RESET_ALWAYS( ( prefix == PN_PREFIX ), KInvalidValue, KErrOverflow );

   920 

   921     if( iBuffer.Length() <= ISI_HEADER_OFFSET_SUBTYPE ) iBuffer.SetLength( ISI_HEADER_OFFSET_SUBTYPE + 1 );

   922     

   923     ASSERT_RESET_ALWAYS( ( iBuffer.Length() >= ISI_HEADER_OFFSET_SUBTYPE ),  KInvalidOffset, KErrOverflow );

   924             

   925     TUint8 type = (( aExtendedResourceId >> 8 ) & 0xFF );       

   926     TUint8 subType = (( aExtendedResourceId >> 16 ) & 0xFF );                                       

   927 

   928     iBuffer[ ISI_HEADER_OFFSET_TYPE ] = type;

   929     iBuffer[ ISI_HEADER_OFFSET_SUBTYPE ] = subType; 

   930     iBuffer[ ISI_HEADER_OFFSET_RESOURCEID ] = prefix;

   931                 

   932     OstTraceExt3( TRACE_NORMAL, DUP1_TISISEND_SETEXTENDEDRESOURCEID, "TIsiSend::SetExtendedResourceId - return;type=%hhu;subType=%hhu;prefix=%hhu", type, subType, prefix );

   933     C_TRACE( ( _T ( "TIsiSend::SetExtendedResourceId return - type = 0x%x, subtype = 0x%x, prefix = 0x%x" ), type, subType, prefix ) );        

   934 

   935     }

   936 

   937 

   938 // -----------------------------------------------------------------------------

   939 // TIsiSubBlock::TIsiSubBlock

   940 // -----------------------------------------------------------------------------

   941 EXPORT_C TIsiSubBlock::TIsiSubBlock

   942         (

   943         TDes8& aMsg, 

   944         TUint16 aSbId,

   945         const TSubBlockType aType

   946         ):  iSubBlockStart( aMsg.Length() ),

   947             iMsg(aMsg),

   948             iSubBlockType(aType)

   949     {

   950     C_TRACE( ( _L ( "TIsiSubBlock::TIsiSubBlock entering - sbId = 0x%x, subBlockType = %d" ), aSbId, aType ) );        

   951     OstTraceExt2( TRACE_NORMAL, TISISUBBLOCK_TISISUBBLOCK, "TIsiSubBlock::TIsiSubBlock - enter;aSbId=%hu;aType=%x", aSbId, ( TUint )&( aType ) );

   952     

   953     

   954     TUint8 byte1(0x00);

   955     TUint8 byte2(0x00);

   956     

   957      

   958         switch( iSubBlockType )

   959             {

   960             case EIsiSubBlockTypeId8Len8:

   961                 {

   962                   iMsg.Append( aSbId ); //sbId 8 bit

   963                   iMsg.Append( 0x00); // length 8 bit

   964                 break;

   965                 }

   966             case EIsiSubBlockTypeId8Len16:

   967                 {

   968                   iMsg.Append( aSbId );

   969                   iMsg.Append( 0x00 ); //filler

   970                   iMsg.Append( 0x00 ); // length 16 bit

   971                   iMsg.Append( 0x00 ); // length 16 bit

   972                 break;

   973                 }

   974             case EIsiSubBlockTypeId16Len8:

   975                 {

   976                   byte1 = ( TUint8 )( ( aSbId & 0xff00 ) >> 8 );

   977                   byte2 = ( TUint8 )( aSbId & 0x00ff ); 

   978 

   979                   iMsg.Append(byte1); // sbId 16 bit

   980                   iMsg.Append(byte2); // sbId 16 bit

   981                   iMsg.Append(0x00); // lenght 8 bit

   982                 break;

   983                 }

   984             case EIsiSubBlockTypeId16Len16:

   985                 {

   986                   byte1 = ( TUint8 )( ( aSbId & 0xff00 ) >> 8 );

   987                   byte2 = ( TUint8 )( aSbId & 0x00ff );

   988 

   989                   iMsg.Append(byte1); // sbId 16 bit

   990                   iMsg.Append(byte2); // sbId 16 bit

   991                   iMsg.Append(0x00); // lenght 16 bit

   992                   iMsg.Append(0x00); // length 16 bit

   993                 break;

   994                 }

   995             case EIsiSubBlockTypeId8Len32:

   996                 {

   997                   iMsg.Append(aSbId); // sbId 8 bit

   998                   iMsg.Append(0x00); // filler

   999                   iMsg.Append(0x00); // filler 

  1000                   iMsg.Append(0x00); // filler 

  1001                   iMsg.Append(0x00); // length 32 bit 

  1002                   iMsg.Append(0x00); // length 32 bit 

  1003                   iMsg.Append(0x00); // length 32 bit 

  1004                   iMsg.Append(0x00); // length 32 bit 

  1005                 break;

  1006                 }

  1007             default:

  1008                 {

  1009                 User::Panic( KInvalidSubBlockType, KErrArgument );

  1010                 break;

  1011                 }

  1012             }

  1013 

  1014     C_TRACE( ( _L ( "TIsiSubBlock::TIsiSubBlock returning, sbId = 0x%x, subBlockType = %d" ), aSbId, aType ) );    

  1015     OstTraceExt2( TRACE_NORMAL, DUP1_TISISUBBLOCK_TISISUBBLOCK, "TIsiSubBlock::TIsiSubBlock - return;aSbId=%hu;aType=%x", aSbId, ( TUint )&( aType ) );

  1016 

  1017     }

  1018 

  1019 // -----------------------------------------------------------------------------

  1020 // TIsiSubBlock::CompleteSubBlock

  1021 // -----------------------------------------------------------------------------

  1022 EXPORT_C TDes8& TIsiSubBlock::CompleteSubBlock

  1023         (

  1024         ) 

  1025     {

  1026     C_TRACE( ( _L ( "TIsiSubBlock::CompleteSubBlock entering " ) ) );   

  1027     OstTrace0( TRACE_NORMAL, TISISUBBLOCK_COMPLETESUBBLOCK, "TIsiSubBlock::CompleteSubBlock - enter" );

  1028     

  1029     TUint8 byte1( 0x00 );

  1030     TUint8 byte2( 0x00 );

  1031     TUint8 byte3( 0x00 );

  1032     TUint8 byte4( 0x00 );

  1033     TUint16 length16(0x0000);

  1034     TUint32 length32(0x00000000);

  1035 

  1036     // make sb length divisible by 4

  1037     while( (iMsg.Length() -iSubBlockStart ) % 4 )

  1038         {

  1039         iMsg.Append( KPaddingByte );

  1040         }

  1041 

  1042     // update subblock length

  1043     switch( iSubBlockType )

  1044         {

  1045         case EIsiSubBlockTypeId8Len8:

  1046             {

  1047               iMsg[iSubBlockStart+1] = TUint8( iMsg.Length()-iSubBlockStart );

  1048             break;

  1049             }

  1050         case EIsiSubBlockTypeId8Len16:

  1051             {

  1052               length16 = TUint16( iMsg.Length()-iSubBlockStart );

  1053               byte1 = ( TUint8 )( ( length16 & 0xff00 ) >> 8 );

  1054               byte2 = ( TUint8 )( length16 & 0x00ff );

  1055               iMsg[iSubBlockStart+2] = byte1;

  1056               iMsg[iSubBlockStart+3] = byte2;

  1057             break;

  1058             }

  1059         case EIsiSubBlockTypeId16Len8:

  1060             {

  1061               iMsg[iSubBlockStart+2] = TUint8( iMsg.Length()-iSubBlockStart );

  1062             break;

  1063             }

  1064         case EIsiSubBlockTypeId16Len16:

  1065             {

  1066               length16 = TUint16( iMsg.Length()-iSubBlockStart );

  1067               byte1 = ( TUint8 )( ( length16 & 0xff00 ) >> 8 );

  1068               byte2 = ( TUint8 )( length16 & 0x00ff );

  1069               iMsg[iSubBlockStart+2] = byte1;

  1070               iMsg[iSubBlockStart+3] = byte2;

  1071             break;

  1072             }

  1073         case EIsiSubBlockTypeId8Len32:

  1074             {

  1075               length32 = TUint32( iMsg.Length()-iSubBlockStart );

  1076               byte1 = ( TUint8 )( ( length32 & 0xff000000 ) >> 24 );

  1077               byte2 = ( TUint8 )( ( length32 & 0x00ff0000 ) >> 16 );

  1078               byte3 = ( TUint8 )( ( length32 & 0x0000ff00 ) >> 8 );

  1079               byte4 = ( TUint8 )( length32 & 0x000000ff );

  1080               iMsg[iSubBlockStart+4] = byte1;

  1081               iMsg[iSubBlockStart+5] = byte2;

  1082               iMsg[iSubBlockStart+6] = byte3;

  1083               iMsg[iSubBlockStart+7] = byte4;

  1084             break;

  1085             }

  1086         default:

  1087             {

  1088             User::Panic( KInvalidSubBlockType, KErrArgument );

  1089             break;

  1090             }

  1091         }

  1092         

  1093     C_TRACE( ( _L ( "TIsiSubBlock::CompleteSubBlock returning " ) ) );   

  1094     OstTrace0( TRACE_NORMAL, DUP1_TISISUBBLOCK_COMPLETESUBBLOCK, "TIsiSubBlock::CompleteSubBlock - return" );    

  1095     

  1096     return iMsg;

  1097 

  1098     }

  1099 

  1100 

  1101 // -----------------------------------------------------------------------------

  1102 // TIsiUtility::CopyFromBigEndian

  1103 // -----------------------------------------------------------------------------

  1104 EXPORT_C void TIsiUtility::CopyFromBigEndian

  1105         (

  1106         const TDesC8& aSource, 

  1107         TDes16& aTarget

  1108         ) 

  1109     {

  1110 

  1111     C_TRACE( ( _L ( "TIsiUtility::CopyFromBigEndian entering " ) ) ); 

  1112     OstTrace0( TRACE_NORMAL, TISIUTILITY_COPYFROMBIGENDIAN, "TIsiUtility::CopyFromBigEndian - enter" );

  1113     

  1114     TUint length(0);

  1115 

  1116     //Checks that data length are acceptable

  1117     if ( aSource.Length() > aTarget.MaxSize() )

  1118         {

  1119         length = aTarget.MaxSize();

  1120         }

  1121     else

  1122         {

  1123         length = ( aSource.Length() / 2 ) * 2;

  1124         }

  1125 

  1126     //Append source to target

  1127     for (TUint i = 0; i < length; i += 2 )

  1128        {

  1129         aTarget.Append(TUint16( aSource[i + 1] | ( aSource[i] << 8) )); 

  1130         }

  1131         

  1132     C_TRACE( ( _L ( "TIsiUtility::CopyFromBigEndian returning. length =  0x%x" ), length ) );      

  1133     OstTrace1( TRACE_NORMAL, DUP1_TISIUTILITY_COPYFROMBIGENDIAN, "TIsiUtility::CopyFromBigEndian - return;length=%u", length );

  1134