#include <phonetisi.h>                    // For ISI_HEADER_SIZE

#include <pn_const.h>                     // For PN_OBJ_ROUTING_REQ...

#include <commisi.h>                      // For Common messages

#include <pn_eventmodem_extisi.h>         // PN_COMMG, PNS_SUBSCRIBED_RESOURCES_...

// HOX! nsisi.h is this also exported by isimsg

#include "nsisi.h"                        // For PN_NAMESERVICE.. 

//#define ISCE_NO_NEED_TO_VALIDATE_RESOURCE // to skip resource validity check

    EISICommunicationManagerNullPointer1,

    EISICommunicationManagerNullPointer2,

    EISICommunicationManagerNullPointer3,

    EISICommunicationManagerNullPointer4,

    EISICommunicationManagerNullPointer5,

    EISICommunicationManagerNullPointer6,

    EISICommunicationManagerNullPointer7,

    EISICommunicationManagerNullPointer8,

    EISICommunicationManagerNullPointer9,

    EISICommunicationManagerNullPointer10,

    EISICommunicationManagerNullPointer11,

    EISICommunicationManagerNullPointer12,

    EISICommunicationManagerNullPointer13,

    EISICommunicationManagerNullPointer14,

    EISICommunicationManagerNullPointer15,

    EISICommunicationManagerNullPointer16,        

    EISICommunicationManagerWrongMessageOrder2,

    EISICommunicationManagerWrongMessage,

    EISICommunicationManagerFatalError,

    EISICommunicationInvalidLength,

    EISICommunicationInvalidLength1,

    EISICommunicationInvalidLength2,

    EISICommunicationInvalidLength3,

    EISICommunicationInvalidLength4,

    EISICommunicationInvalidLength5,

    EISICommunicationInvalidLength6,

    EISICommunicationInvalidLength7,

    EISICommunicationInvalidLength8,

    EISICommunicationInvalidLength9,

    EISICommunicationInvalidLength10,

    EISICommunicationInvalidLength11,

    EISICommunicationInvalidLength12,

    EISICommunicationInvalidLength13,

    EISICommunicationInvalidLength14,

    EISICommunicationManagerSendFailed,

    EISICommunicationManagerSendFailed1,

    EISICommunicationManagerSendFailed2,

    EISICommunicationManagerSendFailed3,

    EISICommunicationManagerSendFailed4,

const TUint8 KDefaultTransactionIdentifier( 0x00 );

const TUint8 KUnitializedObjectIdentifier( 0xff );

const TUint8 KNumberOfBootMessage( 0x04 );

    : iObjectIdentifier( KUnitializedObjectIdentifier ),

      iBootMsgCount( KNumberOfBootMessage )

    C_TRACE( ( _T( "DISICommunicationManager::DISICommunicationManager 0x%x 0x%x>" ), iObjectIdentifier, iRouter ) );

    iRouter = MISIObjectRouterIf::GetIf();    

    iRouter->Connect( KCommunicationManagerUID, iObjectIdentifier, this );

    ASSERT_RESET_ALWAYS( iObjectIdentifier == PN_OBJ_EVENT_MULTICAST, ( EISICommunicationManagerFatalError | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    // Ordinal three as there is zero, one and two used in other places of ISCE.

    TInt err( Kern::MutexCreate( iCommunicationManagerMutex, KCommunicationManagerMutex, KMutexOrdGeneral3 ) );

    C_TRACE( ( _T( "DISICommunicationManager::DISICommunicationManager 0x%x 0x%x<" ), iObjectIdentifier, iRouter ) );

    ASSERT_RESET_ALWAYS( tmp, ( EISICommunicationManagerNullPointer3 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    C_TRACE( ( _T( "DISICommunicationManager::InitDfc 0x%x<" ), aPtr ) );

void DISICommunicationManager::SendNameAddReqs(

        // None

        )

    ASSERT_RESET_ALWAYS( addPtr, ( EISICommunicationManagerNullPointer1 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( addMsg.Length() > ( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ) ),

                         ( EISICommunicationInvalidLength | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    SET_SENDER_OBJ( addPtr, iObjectIdentifier );

    addPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_UTID ] = KDefaultTransactionIdentifier;

    addPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_OBJ ] = iObjectIdentifier;

    addPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = PN_NAME_NOCHG;

    ASSERT_RESET_ALWAYS( addPtr2, ( EISICommunicationManagerNullPointer2 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( addMsg2.Length() > ( ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ) ),

                         ( EISICommunicationInvalidLength1 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    TInt sendResult = iRouter->Send( addMsg, iObjectIdentifier );

    ASSERT_RESET_ALWAYS( ( sendResult == KErrNone ), ( EISICommunicationManagerSendFailed3 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    sendResult = iRouter->Send( addMsg2, iObjectIdentifier );

    ASSERT_RESET_ALWAYS( ( sendResult == KErrNone ), ( EISICommunicationManagerSendFailed4 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    if ( iInitDfc )

        {

        iInitDfc->Cancel();

        delete iInitDfc;

        iInitDfc = NULL;

        }

        iCommunicationManagerMutex = NULL;

void DISICommunicationManager::Receive(

        const TDesC8& aMessage

        )

    TInt err( Kern::MutexWait( *iCommunicationManagerMutex ) );//! check usage of these mutexes (be aware of ordering violations)

        switch(  msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] )

            case PN_APE_COMMGR:

                HandleApeCommunicationManagerMessage( *blockPtr );

                break;

                }

            case PN_COMMGR:

                {

                HandlePnCommgrMessage( *blockPtr );

                break;

                }

            default:

                {

                HandleMessageMulticast( *blockPtr );

                break;

        }

    else

        {

        C_TRACE( ( _T( "DISICommunicationManager booting %d" ), iBootMsgCount ) );

        HandleBootMessage( *blockPtr );

        }

    MemApi::DeallocBlock( *blockPtr );

    Kern::MutexSignal( *iCommunicationManagerMutex );

    C_TRACE( ( _T( "DISICommunicationManager::Receive 0x%x<" ), &aMessage ) );

    }

void DISICommunicationManager::HandleBootMessage(

        const TDesC8& aMessageDuringBoot

        )

    {

    C_TRACE( ( _T( "DISICommunicationManager::HandleBootMessage 0x%x>" ), &aMessageDuringBoot ) );

    const TUint8* messageDuringBootPtr = aMessageDuringBoot.Ptr();

    ASSERT_RESET_ALWAYS( messageDuringBootPtr, ( EISICommunicationManagerNullPointer7 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessageDuringBoot.Length() > ( ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ) ),

                         ( EISICommunicationInvalidLength5 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    if( messageDuringBootPtr[ ISI_HEADER_OFFSET_RESOURCEID ] == PN_NAMESERVICE )

        {

        switch( messageDuringBootPtr[ ISI_HEADER_OFFSET_MESSAGEID ] )

            case PNS_NAME_ADD_IND :

                C_TRACE( ( _T( "DISICommunicationManager::HandleBootMessage PNS_NAME_ADD_IND" ) ) );

                iBootMsgCount--;

                break;

            case PNS_NAME_ADD_RESP :

                C_TRACE( ( _T( "DISICommunicationManager::HandleBootMessage PNS_NAME_ADD_RESP" ) ) );

                ASSERT_RESET_ALWAYS( ( messageDuringBootPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] == PN_NAME_OK ), ( EISICommunicationManagerWrongMessage | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

                iBootMsgCount--;

                break;

            default:

                ASSERT_RESET_ALWAYS( 0, ( EISICommunicationManagerWrongMessageOrder2 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

                break;

        ASSERT_RESET_ALWAYS( 0, ( EISICommunicationManagerWrongMessageOrder | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    C_TRACE( ( _T( "DISICommunicationManager::HandleBootMessage 0x%x<" ), &aMessageDuringBoot ) );

void DISICommunicationManager::HandleApeCommunicationManagerMessage( 

        const TDesC8& aMessageToCommunicationManager

        )

    C_TRACE( ( _T( "DISICommunicationManager::HandleApeCommunicationManagerMessage 0x%x>" ), &aMessageToCommunicationManager ) );

    const TUint8* messagePtr = aMessageToCommunicationManager.Ptr();

    ASSERT_RESET_ALWAYS( messagePtr, ( EISICommunicationManagerNullPointer9 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessageToCommunicationManager.Length() > ( ISI_HEADER_OFFSET_MESSAGEID ) ),

                         ( EISICommunicationInvalidLength7 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    if( messagePtr[ ISI_HEADER_OFFSET_MESSAGEID ] == COMMON_MESSAGE )

        {

        HandleCommunicationManagerCommonMessage( aMessageToCommunicationManager );		

        }

    else

        C_TRACE( ( _T( "DISICommunicationManager::HandleApeCommunicationManagerMessage subscription x%x" ), &aMessageToCommunicationManager ) );

        switch( messagePtr[ ISI_HEADER_OFFSET_MESSAGEID ] )

            {

            case APE_COMMGR_SUBSCRIBE_REQ:

                {

                SendApeCommgrSubscribeResp( aMessageToCommunicationManager );

                iISIIndicationHandler->Subscribe( aMessageToCommunicationManager );        

                break;

                }

            default:

                {

                TRACE_ASSERT_ALWAYS;

                SendCommServiceNotIdentifiedResp( aMessageToCommunicationManager );

                break;

                }

            }

        }

    C_TRACE( ( _T( "DISICommunicationManager::HandleApeCommunicationManagerMessage 0x%x<" ), &aMessageToCommunicationManager ) );	

    }

void DISICommunicationManager::HandlePnCommgrMessage(

        const TDesC8& aMessageToCommunicationManager

        )

    {

    C_TRACE( ( _T( "DISICommunicationManager::HandleCellmoCommunicationManagerMessage 0x%x>" ), &aMessageToCommunicationManager ) );

    const TUint8* messagePtr = aMessageToCommunicationManager.Ptr();

    ASSERT_RESET_ALWAYS( messagePtr, ( EISICommunicationManagerNullPointer15 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessageToCommunicationManager.Length() > ( ISI_HEADER_OFFSET_MESSAGEID ) ),

                         ( EISICommunicationInvalidLength13 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    if( messagePtr[ ISI_HEADER_OFFSET_MESSAGEID ] == COMMON_MESSAGE )

        {

        HandleCommunicationManagerCommonMessage( aMessageToCommunicationManager );	

        C_TRACE( ( _T( "DISICommunicationManager::HandleCellmoCommunicationManagerMessage subscription x%x" ), &aMessageToCommunicationManager ) );

        switch( messagePtr[ ISI_HEADER_OFFSET_MESSAGEID ] )

             {

             case PNS_SUBSCRIBED_RESOURCES_EXTEND_IND: //PNS_SUBSCRIBED_RESOURCES_EXTEND_IND:

                {

                iISIIndicationHandler->Subscribe( aMessageToCommunicationManager );          		  	

                break;

                }

            default:

               {

               TRACE_ASSERT_ALWAYS;

               SendCommServiceNotIdentifiedResp( aMessageToCommunicationManager );              

               break;

               }

            }

        }

    C_TRACE( ( _T( "DISICommunicationManager::HandleCellmoCommunicationManagerMessage 0x%x<" ), &aMessageToCommunicationManager ) );

    }

void DISICommunicationManager::HandleCommunicationManagerCommonMessage(

        const TDesC8& aMessageToCommunicationManager

        )

    {

    C_TRACE( ( _T( "DISICommunicationManager::HandleCommunicationManagerCommonMessage 0x%x>" ), &aMessageToCommunicationManager ) );

    const TUint8* messagePtr = aMessageToCommunicationManager.Ptr();

    ASSERT_RESET_ALWAYS( messagePtr, ( EISICommunicationManagerNullPointer16 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessageToCommunicationManager.Length() > ( ISI_HEADER_OFFSET_MESSAGEID ) ),

                         ( EISICommunicationInvalidLength14 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    if( messagePtr[ ISI_HEADER_OFFSET_MESSAGEID ] == COMMON_MESSAGE )

        {

        ASSERT_RESET_ALWAYS( ( aMessageToCommunicationManager.Length() > ( ISI_HEADER_OFFSET_SUBMESSAGEID ) ),

                         ( EISICommunicationInvalidLength9 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

        switch( messagePtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ] )

            {

            case COMM_ISA_ENTITY_NOT_REACHABLE_RESP:

                {

                C_TRACE( ( _T( "DISICommunicationManager::HandleCommunicationManagerCommonMessage COMM_ISA_ENTITY_NOT_REACHABLE_RESP0 x%x" ), &aMessageToCommunicationManager ) );

                break;

                }

            case COMM_ISI_VERSION_GET_REQ:

                {

                C_TRACE( ( _T( "DISICommunicationManager::HandleCommunicationManagerCommonMessage COMM_ISI_VERSION_GET_REQ x%x" ), &aMessageToCommunicationManager ) );

                SendCommIsiVersionGetResp( aMessageToCommunicationManager );

                break;

                }

            default:

                {

                C_TRACE( ( _T( "DISICommunicationManager::HandleCommunicationManagerCommonMessage unknown COMMON_MESSAGE x%x" ), &aMessageToCommunicationManager ) );

                SendCommServiceNotIdentifiedResp( aMessageToCommunicationManager );

                break;

                }

             }

        }

void DISICommunicationManager::HandleMessageMulticast(

        const TDesC8& aMessageToMulticast

        )

    {

    C_TRACE( ( _T( "DISICommunicationManager::HandleMessageMulticast 0x%x>" ), &aMessageToMulticast ) );

    const TUint8* messageToMulticastPtr = aMessageToMulticast.Ptr();

    ASSERT_RESET_ALWAYS( messageToMulticastPtr, ( EISICommunicationManagerNullPointer10 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessageToMulticast.Length() > ( ISI_HEADER_OFFSET_SENDERDEVICE ) ),

                         ( EISICommunicationInvalidLength8 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    if( ( messageToMulticastPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] != PN_DEV_OWN ) ||

#ifndef ISCE_NO_NEED_TO_VALIDATE_RESOURCE

        ( MISICommunicationManagerIf::IsValidResource( aMessageToMulticast ) )

#else

        ETrue

#endif

      )

        {

        C_TRACE( ( _T( "DISICommunicationManager::HandleMessageMulticast multicasting 0x%x" ), &aMessageToMulticast ) );

        iISIIndicationHandler->Multicast( aMessageToMulticast );

        }

    else

        {

        TRACE_ASSERT_ALWAYS;

        C_TRACE( ( _T( "DISICommunicationManager::HandleMessageMulticast ILLEGAL Resource from APE in message 0x%x" ), &aMessageToMulticast ) );

        }

    C_TRACE( ( _T( "DISICommunicationManager::HandleMessageMulticast 0x%x<" ), &aMessageToMulticast ) );

    }

void DISICommunicationManager::SendApeCommgrSubscribeResp(

        const TDesC8& aMessage

        )

    {

    C_TRACE( ( _T( "DISICommunicationManager::SendApeCommgrSubscribeResp 0x%x>" ), &aMessage ) );

    TUint16 msgLength( ISI_HEADER_SIZE + SIZE_APE_COMMGR_SUBSCRIBE_RESP );

    TDes8& pnsSubscribeResp = MemApi::AllocBlock( msgLength );

    pnsSubscribeResp.SetLength( msgLength );

    TUint8* msgPtr = const_cast<TUint8*>( aMessage.Ptr() );

    ASSERT_RESET_ALWAYS( msgPtr, ( EISICommunicationManagerNullPointer4 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessage.Length() > ( ISI_HEADER_OFFSET_TRANSID ) ),

                         ( EISICommunicationInvalidLength2 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    TUint8* pnsSubscribeRespPtr = const_cast<TUint8*>( pnsSubscribeResp.Ptr() );

    ASSERT_RESET_ALWAYS( pnsSubscribeRespPtr, ( EISICommunicationManagerNullPointer5 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( pnsSubscribeResp.Length() > ( ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_RESP_OFFSET_RESULT ) ),

                         ( EISICommunicationInvalidLength3 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    pnsSubscribeRespPtr[ ISI_HEADER_OFFSET_MEDIA ] = msgPtr[ ISI_HEADER_OFFSET_MEDIA ];

    SET_RECEIVER_DEV( pnsSubscribeRespPtr, GET_SENDER_DEV( aMessage ) );

    SET_SENDER_DEV( pnsSubscribeRespPtr, PN_DEV_OWN );

    pnsSubscribeRespPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_APE_COMMGR;

    SET_LENGTH( pnsSubscribeRespPtr, ( msgLength - PN_HEADER_SIZE ) );

    SET_RECEIVER_OBJ( pnsSubscribeRespPtr, GET_SENDER_OBJ( aMessage ) );

    SET_SENDER_OBJ( pnsSubscribeRespPtr, iObjectIdentifier );

    pnsSubscribeRespPtr[ ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_RESP_OFFSET_TRANSID ] = msgPtr[ ISI_HEADER_OFFSET_TRANSID ];

    pnsSubscribeRespPtr[ ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_RESP_OFFSET_MESSAGEID ] = APE_COMMGR_SUBSCRIBE_RESP;

    pnsSubscribeRespPtr[ ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_RESP_OFFSET_RESULT ] = msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN ? APE_COMMGR_OK : APE_COMMGR_NOT_ALLOWED;

    TRACE_ASSERT( APE_COMMGR_OK == pnsSubscribeRespPtr[ ISI_HEADER_SIZE + APE_COMMGR_SUBSCRIBE_RESP_OFFSET_RESULT ] );

    TInt sendResult = iRouter->Send( pnsSubscribeResp, iObjectIdentifier );

    ASSERT_RESET_ALWAYS( ( sendResult == KErrNone ), ( EISICommunicationManagerSendFailed2 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );    

    C_TRACE( ( _T( "DISICommunicationManager::SendApeCommgrSubscribeResp 0x%x<" ), &aMessage ) );

    }

void DISICommunicationManager::SendCommServiceNotIdentifiedResp(

        const TDesC8& aMessage

        )

    //  check if possible to go in wild loop if incoming message is not_reachable_resp 

    TInt commonServiceNotIdentifiedLength( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP );       

    TDes8& commonServiceNotIdentifiedResp = MemApi::AllocBlock( commonServiceNotIdentifiedLength );

    commonServiceNotIdentifiedResp.SetLength( commonServiceNotIdentifiedLength );

    TUint8* commonServiceNotIdentifiedRespPtr( const_cast<TUint8*>( commonServiceNotIdentifiedResp.Ptr() ) );

    ASSERT_RESET_ALWAYS( commonServiceNotIdentifiedRespPtr, ( EISICommunicationManagerNullPointer6 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( commonServiceNotIdentifiedResp.Length() > ( ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE3 ) ),

                         ( EISICommunicationInvalidLength4 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    const TUint8* receivedMsgPtr( aMessage.Ptr() );

    ASSERT_RESET_ALWAYS( receivedMsgPtr, ( EISICommunicationManagerNullPointer11 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( aMessage.Length() > ( ISI_HEADER_OFFSET_SUBMESSAGEID ) ),

                         ( EISICommunicationInvalidLength10 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    SetIsiHeaderForCommonMessage( commonServiceNotIdentifiedResp, aMessage );    

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_SUBMESSAGEID ] = COMM_SERVICE_NOT_IDENTIFIED_RESP;

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_NOTSERVEDMESSAGEID ] = receivedMsgPtr[ ISI_HEADER_OFFSET_MESSAGEID ];

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE1 ] = KFiller;

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_NOTSERVEDSUBMESSAGEID ] = receivedMsgPtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ];

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE2 ] = KFiller;

    commonServiceNotIdentifiedRespPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE3 ] = KFiller;

    TInt sendResult = iRouter->Send( commonServiceNotIdentifiedResp, iObjectIdentifier );

    ASSERT_RESET_ALWAYS( ( sendResult == KErrNone ), ( EISICommunicationManagerSendFailed | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    C_TRACE( ( _T( "DISICommunicationManager::SendCommServiceNotIdentifiedResp 0x%x<" ), &aMessage ) );

void DISICommunicationManager::SendCommIsiVersionGetResp(

        const TDesC8& aMessage

        )

    TInt commonIsiVersionGetRespLength( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP );

    TDes8& commonIsiVersionGetResp = MemApi::AllocBlock( commonIsiVersionGetRespLength );

    commonIsiVersionGetResp.SetLength( commonIsiVersionGetRespLength );

    TUint8* commonIsiVersionGetRespPtr( const_cast<TUint8*>( commonIsiVersionGetResp.Ptr() ) );

    ASSERT_RESET_ALWAYS( commonIsiVersionGetRespPtr, ( EISICommunicationManagerNullPointer8 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    ASSERT_RESET_ALWAYS( ( commonIsiVersionGetResp.Length() > ( ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_FILLERBYTE3 ) ),

                         ( EISICommunicationInvalidLength6 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    const TUint8* receivedMsgPtr( aMessage.Ptr() );

    ASSERT_RESET_ALWAYS( receivedMsgPtr, ( EISICommunicationManagerNullPointer12 | EDISICommunicationManagerTraceId << KClassIdentifierShift ) );

    SetIsiHeaderForCommonMessage( commonIsiVersionGetResp, aMessage );