diff -r 6295dc2169f3 -r 8486d82aef45 connectivitylayer/isce/isinameservice_dll/src/isinameservice.cpp --- a/connectivitylayer/isce/isinameservice_dll/src/isinameservice.cpp Wed Apr 21 14:29:55 2010 +0300 +++ b/connectivitylayer/isce/isinameservice_dll/src/isinameservice.cpp Tue Oct 19 13:16:20 2010 +0300 @@ -15,7 +15,6 @@ * */ - #include // For Kern #include "isinameservice.h" // For DISINameService #include "misiobjectrouterif.h" // For MISIObjectRouterIf @@ -24,86 +23,101 @@ #include // For ISI_HEADER_SIZE #include // For PN_NAMESERVICE #include // For PN - -#ifdef INTERNAL_FLAG_ISI_ROUTER_IN_USE +#include "misiobjectrouterif.h" // For MISIObjectRouterIf #include "isihelpers.h" // For SET_RECEIVER_OBJ... -#else -#include "iadhelpers.h" // For SET_RECEIVER_OBJ... +#include "namerecords.h" // For DNameRecords +#include "routerisi.h" // For PN_ROUTER +#include // For SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP + +#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE +#include "ape_commgrisi.h" // For APE_COMMGR +#define ISCE_INTERNAL_EXTENDED_RESOURCE_ROUTING_SUPPORTED +//#include "isinameserviceextended.h" // For DISINameServiceExtended #endif -#include "namerecords.h" // For DNameRecords -#include // For THIS_DEVICE -#include // For SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP + // Faults enum TISINameServiceFaults { EISINameServiceMemAllocFailure = 0x01, EISINameServiceNullPointer, + EISINameServiceNullPointer1, + EISINameServiceNullPointer2, + EISINameServiceNullPointer6, + EISINameServiceNullPointer7, + EISINameServiceNullPointer8, + EISINameServiceNullPointer9, + EISINameServiceNullPointer10, + EISINameServiceNullPointer11, + EISINameServiceNullPointer12, + EISINameServiceNullPointer13, + EISINameServiceNullPointer14, + EISINameServiceNullPointer15, + EISINameServiceNullPointer16, + EISINameServiceNullPointer17, + EISINameServiceNullPointer18, + EISINameServiceNullPointer19, + EISINameServiceWrongLength, + EISINameServiceWrongLength1, + EISINameServiceWrongLength6, + EISINameServiceWrongLength7, + EISINameServiceWrongLength8, + EISINameServiceWrongLength9, + EISINameServiceWrongLength10, + EISINameServiceWrongLength11, + EISINameServiceWrongLength12, EISINameServiceUnknownMessage, EISINameServiceMutexCreateFailed, EISINameServiceMutexWaitFailed, + EISINameServiceSendFailed, + EISINameServiceFatalError, +#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + EISINameServiceWrongLength2, + EISINameServiceWrongLength3, + EISINameServiceNullPointer3, + EISINameServiceNullPointer4, + EISINameServiceNullPointer5, + EISINameServiceNameCreateFailed, + EISINameServiceNameCreateFailed1, + EISINameServiceNameCreateFailed2, + EISINameServiceNameCreateFailed3, + EISINameServiceNameCreateFailed4, + EISINameServiceNameCreateFailed5, + EISINameServiceNameCreateFailed6, + EISINameServiceNameCreateFailed7, + EISINameServiceNameCreateFailed8, + EISINameServiceNameCreateFailed9, + EISINameServiceNameCreateFailed10, + EISINameServiceNameCreateFailed11, + EISINameServiceNameCreateFailed12, + EISINameServiceNameCreateFailed13, + EISINameServiceNameCreateFailed14, + EISINameServiceNameCreateFailed15, + EISINameServiceNameCreateFailed16, + EISINameServiceNameCreateFailed17, + EISINameServiceNameCreateFailed18, + EISINameServiceWrongResponse, + EISINameServiceNameExtendedCreateFailed, + EISINameServiceExtendedNullPointer, + EISINameServiceNameNotCommgrResource, + EISINameServiceNameNotCommgrDevice, + EISINameServiceLookUpForPhoNetAddressAndFlagsFailed, +#endif // ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE }; - -/* PUTB8 macro writes byte value to given address. - * This macro is used mainly by other PUTBXX macros. - */ -#define PUTB8(p,v) \ - {(*(TUint8 *)(p)) = ((TUint8)(v));} - - -/* PUTB16 macro writes 16-bit value in Big Endian format - * to given address. 16-bit value is written as two separate - * bytes, and so this macro can write 16-bit value to whatever - * address, regardless of the processor alignment restrictions - */ -#define PUTB16(p,v) \ - {PUTB8((p),(TUint16)(v)>>8); PUTB8((TUint8*)(p)+1,v);} - - -/* PUTB32 macro writes 32-bit value in Big Endian format - * to given address. 32-bit value is written as four separate - * bytes, and so this macro can write 32-bit value to whatever - * address, regardless of the processor alignment restrictions - */ -#define PUTB32(p,v) \ - {PUTB16((p),(TUint32)(v)>>16); PUTB16((TUint8*)(p)+2,(TUint32)(v));} - - -/** - * Big Endian to local endian type - */ - /* GETB8 macro returns byte value from given address. - * This macro is used mainly by other GETBXX macros. - */ -#define GETB8(p) \ - (*(TUint8 *)(p)) - - -/* GETB16 macro reads 16-bit value in Big Endian format - * from given address. 16-bit value is read as two separate - * bytes, and so this macro can read 16-bit value from whatever - * address, regardless of the processor alignment restrictions - */ -#define GETB16(p) \ - (((TUint16) GETB8(p)<<8) | (TUint16) GETB8((TUint8 *)(p)+1)) - - -/* GETB32 macro reads 32-bit value in Big Endian format - * from given address. 32-bit value is read as four separate - * bytes, and so this macro can read 32-bit value from whatever - * address, regardless of the processor alignment restrictions - */ -#define GETB32(p) \ - (((TUint32) GETB16(p)<<16) | (TUint32) GETB16((TUint8 *)(p)+2)) - - const TUint32 KNameServiceUID( 0x2002A5A1 ); const TUint8 KFiller( 0 ); +const TUint8 KAlwaysAssert( 0x00 ); + +const TUint16 KOneMatch( 0x00001 ); DISINameService* DISINameService::iThisptr = NULL; DMutex* DISINameService::iNameServiceMutex = NULL; _LIT8( KNameServiceMutex, "KNameServiceMutex" ); - +const TUint8 KEightBitShift( 8 ); +const TUint8 KSixteenBitShift( 16 ); +const TUint8 KDeviceIdentifierPhoNetAddressShift( KEightBitShift ); +const TUint16 KUninitializedPhoNetAddress( 0x0000 ); +const TUint8 KRouterObjId( 0xFA ); // Only internally agreed inside isi router DISINameService::DISINameService( // None @@ -111,12 +125,29 @@ : iObjId( 0x00 ) { C_TRACE( ( _T( "DISINameService::DISINameService 0x%x 0x%x>" ), iObjId, iRouter ) ); - iRouter = MISIObjectRouterIf::Connect( KNameServiceUID, iObjId, this ); - ASSERT_RESET_ALWAYS( iRouter, ( EISINameServiceNullPointer | EDISINameServiceTraceId << KClassIdentifierShift ) ); iNameRecords = new DNameRecords(); - ASSERT_RESET_ALWAYS( iNameRecords, ( EISINameServiceMemAllocFailure | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( iNameRecords ), + ( EISINameServiceMemAllocFailure | EDISINameServiceTraceId << KClassIdentifierShift ) ); TInt err( Kern::MutexCreate( iNameServiceMutex, KNameServiceMutex, KMutexOrdGeneral0 ) ); - ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EISINameServiceMutexCreateFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( KErrNone == err ), + ( EISINameServiceMutexCreateFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); + iRouter = MISIObjectRouterIf::GetIf(); + ASSERT_RESET_ALWAYS( ( iRouter ), + ( EISINameServiceNullPointer | EDISINameServiceTraceId << KClassIdentifierShift ) ); + iRouter->Connect( KNameServiceUID, iObjId, this ); + C_TRACE( ( _T( "DISINameService::DISINameService 0x%x" ), iObjId ) ); + ASSERT_RESET_ALWAYS( ( iObjId == PN_OBJ_ROUTING_REQ ), + ( EISINameServiceFatalError | EDISINameServiceTraceId << KClassIdentifierShift ) ); + // Starting from here we add the PN_ROUTER object 'statically' to Name Service + TUint32 name = PN_ROUTER; + TUint16 phonetAddr = ( ( PN_DEV_OWN << KDeviceIdentifierPhoNetAddressShift ) | KRouterObjId ); + TUint8 flags = PN_NAME_NOCHG; + err = iNameRecords->AddName( name, phonetAddr, flags ); +#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + iISINameServiceExtended = new DISINameServiceExtended( this ); + ASSERT_RESET_ALWAYS( ( iISINameServiceExtended ), ( EISINameServiceNameExtendedCreateFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); +#endif // ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + iThisptr = this; C_TRACE( ( _T( "DISINameService::DISINameService 0x%x 0x%x<" ), iObjId, iRouter ) ); } @@ -130,305 +161,264 @@ delete iNameRecords; iNameRecords = NULL; } - +#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + if( iISINameServiceExtended ) + { + delete iISINameServiceExtended; + iISINameServiceExtended = NULL; + } +#endif C_TRACE( ( _T( "DISINameService::~DISINameService<" ) ) ); } - -void DISINameService::Receive( const TDesC8& aMessage ) +void DISINameService::Receive( + const TDesC8& aMessage + ) { C_TRACE( ( _T( "DISINameService::Receive 0x%x>" ), &aMessage ) ); - TInt err( Kern::MutexWait( *iNameServiceMutex ) ); - ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EISINameServiceMutexWaitFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); + // This to be signaled (and only) when send back. + LockNameServiceDMutex(); TUint8* msgPtr( (TUint8*)aMessage.Ptr() ); + TUint32 resource = GetResourceUsedInMessage( aMessage ); + if( resource == PN_NAMESERVICE + ) + { + C_TRACE( ( _T( "DISINameService::Receive to PN_NAMESERVICE" ) ) ); + HandlePnsNameMessage( aMessage ); + } - TUint8 resource = msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ]; - if( resource == PN_NAMESERVICE ) - { - C_TRACE( ( _T( "DISINameService message to PN_NAMESERVICE" ) ) ); - HandlePNSNameMessage( aMessage ); - } + // Messages which are to be Resource routed. else { - //RouterByResource( aMessage ); - - C_TRACE( ( _T( "DISINameService message to RESOURCE : %d" ),resource ) ); - //look for nametable by resource in message - TUint16 phonetAddress = 0; - TInt32 error = iNameRecords->LookupPhonetAddress(resource, &phonetAddress); - + C_TRACE( ( _T( "DISINameService::Receive to Resource : 0x%x" ),resource ) ); + TUint16 phoNetAddress( KUninitializedPhoNetAddress ); + TInt32 error = iNameRecords->LookupPhonetAddress( resource, &phoNetAddress ); if( KErrNone == error ) { - //change phonet addr to current message from table entries - - - msgPtr[ISI_HEADER_OFFSET_RECEIVERDEVICE] = (TUint8)( (phonetAddress & 0xFF00) >> 8); - msgPtr[ISI_HEADER_OFFSET_RECEIVEROBJECT] = (TUint8) (phonetAddress & 0xFF); - TDes8* messagePtr = reinterpret_cast( const_cast(&aMessage) ); - - C_TRACE( ( _T( "<-DISINameService message to recDev: 0x%x" ),msgPtr[ISI_HEADER_OFFSET_RECEIVERDEVICE] ) ); - C_TRACE( ( _T( "<-DISINameService message to recObj: 0x%x" ),msgPtr[ISI_HEADER_OFFSET_RECEIVEROBJECT] ) ); - - //send data to router for handling - iRouter->Send( *messagePtr, iObjId); + // Change phonet addr to current message from table entries. + msgPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ] = (TUint8) ( phoNetAddress >> KEightBitShift ); + msgPtr[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] = (TUint8) ( phoNetAddress ); + TDes8* messagePtr = reinterpret_cast( const_cast( &aMessage ) ); + C_TRACE( ( _T( "DISINameService message to recDev: 0x%x recObj: 0x%x" ), msgPtr[ ISI_HEADER_OFFSET_RECEIVERDEVICE ], msgPtr[ ISI_HEADER_OFFSET_RECEIVEROBJECT ] ) ); + SendToRouter( *messagePtr ); } else { - //construct not reachable resp message - C_TRACE( ( _T( "DISINameService::Receive **ELSE** !!" ) ) ); + C_TRACE( ( _T( "DISINameService::Receive no Resource found : 0x%x" ), resource ) ); + + TRACE_ASSERT_ALWAYS( KAlwaysAssert ); BuildAndSendCommIsaEntityNotReachableResp(aMessage); + } } - Kern::MutexSignal( *iNameServiceMutex ); - C_TRACE( ( _T( "DISINameService::DISINameService<" ) ) ); + C_TRACE( ( _T( "DISINameService::Receive 0x%x<" ), &aMessage ) ); } -void DISINameService::HandleNameQueryResp( const TDesC8& aMessage, const TUint8* msgPtr ) + +void DISINameService::HandleNameQueryReq( + const TDesC8& aPnsNameQueryReq + ) { - C_TRACE( ( _T( "DISINameService::HandleNameQueryResp>" ) ) ); + C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x>" ) ,&aPnsNameQueryReq ) ); + const TUint8* msgPtr = aPnsNameQueryReq.Ptr(); + ASSERT_RESET_ALWAYS( msgPtr, ( EISINameServiceNullPointer6 | EDISINameServiceTraceId << KClassIdentifierShift ) ); TUint32 name = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_NAME ] ); TUint32 mask = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_BITMASK ] ); - RArray nameTable; - TInt32 count = iNameRecords->NameQuery( name, mask, &nameTable ); + RArray nameTable; + iNameRecords->NameQuery( name, mask, &nameTable ); + TUint32 count( nameTable.Count() ); + // Hoks! not needed ISI_HEADER_SIZE because in below resp contains assumption that there is one entry always. TUint16 msgLength = ( SIZE_PNS_NAME_QUERY_RESP + ( count * SIZE_PN_NAME_SRV_ITEM_STR ) ); TDes8& respMsg = MemApi::AllocBlock( msgLength ); respMsg.SetLength( msgLength ); TUint8* respPtr = const_cast( respMsg.Ptr() ); - - respPtr[ ISI_HEADER_OFFSET_MEDIA ] = msgPtr[ ISI_HEADER_OFFSET_MEDIA ]; - SET_RECEIVER_DEV( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] ); - SET_SENDER_DEV( respPtr, PN_DEV_OWN ); - respPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; - SET_LENGTH( respPtr, ( msgLength - PN_HEADER_SIZE ) ); - SET_RECEIVER_OBJ( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDEROBJECT ] ); - SET_SENDER_OBJ( respPtr, PN_OBJ_ROUTER ); - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_UTID ] = msgPtr[ ISI_HEADER_OFFSET_TRANSID ]; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_SUBFUNCTION ]= PNS_NAME_QUERY_RESP; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_TOTALMATCHES ] = count >> 8; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_TOTALMATCHES + 1 ] = count; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG ] = count >> 8; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG + 1 ] = count; + ASSERT_RESET_ALWAYS( respPtr, ( EISINameServiceNullPointer7 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + SetIsiHeaderForResp( respMsg, aPnsNameQueryReq, PNS_NAME_QUERY_RESP ); + PUTB16( &respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_TOTALMATCHES ], count ); + PUTB16( &respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG ], count ); respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_RESERVED1 ] = KFiller; respPtr[ ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_RESERVED2 ] = KFiller; - - TUint16 index = ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL; - for( int i = 0; i < count; i++) + TUint16 index( ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL ); + C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x entry count %d" ) ,&aPnsNameQueryReq, count ) ); + for( TInt i( 0 ); i < count; i++ ) { - //AddNameTable(); - TNameTable* tmp = (nameTable)[ i ]; - - // Name - respPtr[ index++ ] = (TUint8)(tmp->iName >> 24); - respPtr[ index++ ] = (TUint8)(tmp->iName >> 16); - respPtr[ index++ ] = (TUint8)(tmp->iName >> 8); - respPtr[ index++ ] = (TUint8)(tmp->iName); - // DevId - respPtr[ index++ ] = (TUint8)(tmp->iPhonetAddress >> 8); - // ObjId - respPtr[ index++ ] = (TUint8)(tmp->iPhonetAddress); - // Record flags - respPtr[ index++ ] = tmp->iFlags; - respPtr[ index++ ] = KFiller; // Reserved + ASSERT_RESET_ALWAYS( ( respMsg.Length() > index + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ), + ( EISINameServiceWrongLength7 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TNameTableEntry* tmp = ( nameTable )[ i ]; + if ( ( (TUint8)( tmp->iPhonetAddress ) == PN_OBJ_ROUTING_REQ ) && + ( tmp->iName == name ) ) + { + TRACE_ASSERT_ALWAYS( KAlwaysAssert ); + Kern::Printf("PNS_NAME_QUERY_REQ NOTE! Obj Id 0 not valid!! name 0x%08x txDev 0x%02x txObj 0x%02x", name, msgPtr[ISI_HEADER_OFFSET_SENDERDEVICE], msgPtr[ISI_HEADER_OFFSET_SENDEROBJECT] ); + } + PUTB32( &respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ], tmp->iName ); + respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ] = (TUint8)( tmp->iPhonetAddress >> KEightBitShift ); + respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_OBJ ] = (TUint8)( tmp->iPhonetAddress ); + respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = tmp->iFlags; + respPtr[ index + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ] = KFiller; + index += SIZE_PN_NAME_SRV_ITEM_STR; } - - iRouter->Send( respMsg, iObjId ); - TDes8* block = reinterpret_cast( const_cast(&aMessage) ); + SendToRouter( respMsg ); + TDes8* block = reinterpret_cast( const_cast(&aPnsNameQueryReq) ); MemApi::DeallocBlock( *block ); - C_TRACE( ( _T( "DISINameService::HandleNameQueryResp<" ) ) ); + C_TRACE( ( _T( "DISINameService::HandleNameQueryReq 0x%x<" ) ,&aPnsNameQueryReq ) ); } -void DISINameService::HandleNameRemoveResp( const TDesC8& aMessage, const TUint8* msgPtr ) +void DISINameService::HandleNameRemoveReq( + const TDesC8& aPnsNameRemoveReq + ) { - C_TRACE( ( _T( "DISINameService::HandleNameRemoveResp>" ) ) ); + C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq 0x%x>" ), &aPnsNameRemoveReq ) ); + const TUint8* msgPtr = aPnsNameRemoveReq.Ptr(); + ASSERT_RESET_ALWAYS( msgPtr, ( EISINameServiceNullPointer8 | EDISINameServiceTraceId << KClassIdentifierShift ) ); TUint32 name = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_REQ_OFFSET_NAME ] ); - - TInt8 err = iNameRecords->RemoveName( name ); - C_TRACE( ( _T( "DISINameService PNS_NAME_REMOVE_RESP 0x%x>" ), name ) ); - + TUint16 phonetAddress( KUninitializedPhoNetAddress ); + TUint8 flags( 0x00 ); + // Need to get these values in here to guarantee that they are the same in IND if needed. + TInt error = iNameRecords->LookupNamePhonetAddressAndFlags( name, &phonetAddress, &flags ); + TRACE_ASSERT_ALWAYS( ( KErrNone == error ) ); + const TUint8 err = iNameRecords->RemoveName( name ); + C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq PNS_NAME_REMOVE_RESP name 0x%x err 0x%x" ), name, err ) ); TUint16 msgLength( ISI_HEADER_SIZE + SIZE_PNS_NAME_REMOVE_RESP ); TDes8& respMsg = MemApi::AllocBlock( msgLength ); respMsg.SetLength( msgLength ); TUint8* respPtr = const_cast( respMsg.Ptr() ); - - respPtr[ ISI_HEADER_OFFSET_MEDIA ] = msgPtr[ ISI_HEADER_OFFSET_MEDIA ]; - SET_RECEIVER_DEV( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] ); - SET_SENDER_DEV( respPtr, PN_DEV_OWN ); - respPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; - SET_LENGTH( respPtr, ( msgLength - PN_HEADER_SIZE ) ); - SET_RECEIVER_OBJ( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDEROBJECT ] ); - SET_SENDER_OBJ( respPtr, PN_OBJ_ROUTER ); - respPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_UTID ] = msgPtr[ ISI_HEADER_OFFSET_TRANSID ]; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_SUBFUNCTION ] = PNS_NAME_REMOVE_RESP; + ASSERT_RESET_ALWAYS( respPtr, ( EISINameServiceNullPointer9 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( respMsg.Length() > ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_REASON ), + ( EISINameServiceWrongLength6 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + SetIsiHeaderForResp( respMsg, aPnsNameRemoveReq, PNS_NAME_REMOVE_RESP ); if( msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN ) { + C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq from own device err 0x%x" ) ) ); respPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_REASON ] = err; - iRouter->Send( respMsg, iObjId ); - + SendToRouter( respMsg ); if( PN_NAME_OK == err ) { - C_TRACE( ( _T( "DISINameService PNS_NAME_REMOVE_IND>" ) ) ); - msgLength = ( SIZE_PNS_NAME_REMOVE_IND + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL ); - TDes8& indMsg = MemApi::AllocBlock( msgLength ); - indMsg.SetLength( msgLength ); - TUint8* indPtr = const_cast( indMsg.Ptr() ); - - indPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_ROUTING_REQ; - SET_RECEIVER_DEV( indPtr, msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] ); - SET_SENDER_DEV( indPtr, PN_DEV_OWN ); - indPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; - SET_LENGTH( indPtr, ( msgLength - PN_HEADER_SIZE ) ); - SET_RECEIVER_OBJ( indPtr, PN_OBJ_EVENT_MULTICAST ); //communicationmanager - SET_SENDER_OBJ( indPtr, PN_OBJ_ROUTER ); - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_UTID ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_SUBFUNCTION ]= PNS_NAME_REMOVE_IND; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_TOTALMATCHES ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_TOTALMATCHES + 1 ] = 0x01; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_MATCHESINMSG ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_MATCHESINMSG + 1 ] = 0x01; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_RESERVED1 ] = KFiller; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_RESERVED2 ] = KFiller; - PUTB32( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ], name ); - - iRouter->Send( indMsg, iObjId ); - TDes8* block = reinterpret_cast( const_cast(&aMessage) ); - MemApi::DeallocBlock( *block ); - C_TRACE( ( _T( "DISINameService PNS_NAME_QUERY_IND<" ) ) ); + TxPnsNameRemoveInd( aPnsNameRemoveReq, name, phonetAddress, flags ); } - C_TRACE( ( _T( "DISINameService PNS_NAME_REMOVE_RESP<" ) ) ); + // No need to send indication if removal did not succeed as state is the same. } else { - C_TRACE( ( _T( "DISINameService::HandlePNSNameMessage PNS_NAME_REMOVE_REQ from other device, PN_NAME_NOT_ALLOWED" ) ) ); + C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq PNS_NAME_REMOVE_REQ from other device not allowed" ) ) ); respPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_RESP_OFFSET_REASON ] = PN_NAME_NOT_ALLOWED; - iRouter->Send( respMsg, iObjId ); + SendToRouter( respMsg ); } - C_TRACE( ( _T( "DISINameService::HandleNameRemoveResp<" ) ) ); + TDes8* block = reinterpret_cast( const_cast(&aPnsNameRemoveReq) ); + MemApi::DeallocBlock( *block ); + C_TRACE( ( _T( "DISINameService::HandleNameRemoveReq 0x%x<" ), &aPnsNameRemoveReq ) ); } -void DISINameService::HandlePNSNameMessage( const TDesC8& aMessage ) +void DISINameService::SendToRouter( + TDes8& aMessage + ) { - C_TRACE( ( _T( "DISINameService::HandlePNSNameMessage 0x%x>" ), &aMessage ) ); + C_TRACE( ( _T( "DISINameService::SendToRouter 0x%x>" ), &aMessage ) ); + FreeNameServiceDMutex(); + TInt value = iRouter->Send( aMessage, iObjId ); + ASSERT_RESET_ALWAYS( value == KErrNone, ( EISINameServiceSendFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); + C_TRACE( ( _T( "DISINameService::SendToRouter 0x%x<" ), &aMessage ) ); + } + +void DISINameService::HandlePnsNameMessage( const TDesC8& aMessage ) + { + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage 0x%x>" ), &aMessage ) ); const TUint8* msgPtr( aMessage.Ptr() ); - TInt8 err( KErrArgument ); switch( msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] ) { case PNS_NAME_QUERY_REQ: { - C_TRACE( ( _T( "DISINameService PNS_NAME_QUERY_REQ>" ) ) ); - HandleNameQueryResp( aMessage, msgPtr ); - C_TRACE( ( _T( "DISINameService PNS_NAME_QUERY_REQ<" ) ) ); + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_QUERY_REQ" ) ) ); + HandleNameQueryReq( aMessage ); break; } case PNS_NAME_ADD_REQ: { - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_REQ>" ) ) ); - - TUint16 msgLength( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_RESP ); - TDes8& respMsg = MemApi::AllocBlock( msgLength ); - respMsg.SetLength( msgLength ); - TUint8* respPtr = const_cast( respMsg.Ptr() ); - - respPtr[ ISI_HEADER_OFFSET_MEDIA ] = msgPtr[ ISI_HEADER_OFFSET_MEDIA ]; - SET_RECEIVER_DEV( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] ); - SET_SENDER_DEV( respPtr, PN_DEV_OWN ); - respPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; - SET_LENGTH( respPtr, ( msgLength - PN_HEADER_SIZE ) ); - SET_RECEIVER_OBJ( respPtr, msgPtr[ ISI_HEADER_OFFSET_SENDEROBJECT ] ); - SET_SENDER_OBJ( respPtr, PN_OBJ_ROUTER ); - respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_UTID ] = msgPtr[ ISI_HEADER_OFFSET_TRANSID ]; - respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_SUBFUNCTION ] = PNS_NAME_ADD_RESP; - - if( msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN ) - { - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_REQ from this device" ) ) ); - TUint32 name = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY ] ); - TUint16 phonetAddr = GETB16( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ] ); - TUint8 flags = msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ]; - err = iNameRecords->AddName( name, phonetAddr, flags ); - respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = err; - iRouter->Send( respMsg, iObjId ); - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_RESP from this device<" ) ) ); - if( err == PN_NAME_OK ) - { - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_IND>" ) ) ); - msgLength = ( SIZE_PNS_NAME_ADD_IND + ( SIZE_PN_NAME_SRV_ITEM_STR ) ); - TDes8& indMsg = MemApi::AllocBlock( msgLength ); - indMsg.SetLength( msgLength ); - TUint8* indPtr = const_cast( indMsg.Ptr() ); - indPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_ROUTING_REQ; - SET_RECEIVER_DEV( indPtr, msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] ); - SET_SENDER_DEV( indPtr, PN_DEV_OWN ); - indPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; - SET_LENGTH( indPtr, ( msgLength - PN_HEADER_SIZE ) ); - SET_RECEIVER_OBJ( indPtr, PN_OBJ_EVENT_MULTICAST ); //communicationmanager - SET_SENDER_OBJ( indPtr, PN_OBJ_ROUTER ); - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_UTID ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_SUBFUNCTION ]= PNS_NAME_ADD_IND; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_TOTALMATCHES ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_TOTALMATCHES + 1 ] = 0x01; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_MATCHESINMSG ] = 0x00; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_MATCHESINMSG + 1 ] = 0x01; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_RESERVED1 ] = KFiller; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_RESERVED2 ] = KFiller; - PUTB32( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ], name ); - PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ], phonetAddr ); - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = flags; - indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ] = KFiller; - iRouter->Send( indMsg, iObjId ); - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_IND<" ) ) ); - } - } - else - { - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_REQ from other device>" ) ) ); - respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = PN_NAME_NOT_ALLOWED; - iRouter->Send( respMsg, iObjId ); - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_RESP from other device<" ) ) ); - } - TDes8* block = reinterpret_cast( const_cast(&aMessage) ); - MemApi::DeallocBlock( *block ); - C_TRACE( ( _T( "DISINameService PNS_NAME_ADD_REQ<" ) ) ); + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_ADD_REQ" ) ) ); + HandleNameAddReq( aMessage ); break; } case PNS_NAME_REMOVE_REQ: { - C_TRACE( ( _T( "DISINameService PNS_NAME_REMOVE_REQ>" ) ) ); - HandleNameRemoveResp( aMessage, msgPtr ); - C_TRACE( ( _T( "DISINameService PNS_NAME_REMOVE_REQ<" ) ) ); + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage PNS_NAME_REMOVE_REQ" ) ) ); + HandleNameRemoveReq( aMessage ); + break; + } + case COMMON_MESSAGE: + { + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage COMMON_MESSAGE" ) ) ); + HandleCommonMessage( aMessage ); break; } default: { - ASSERT_RESET_ALWAYS( 0, ( EISINameServiceUnknownMessage | EDISINameServiceTraceId << KClassIdentifierShift ) ); - C_TRACE( ( _T( "DISINameService::HandlePNSNameMessage unknown NAMESERVICE message" ) ) ); + TRACE_ASSERT_ALWAYS( KAlwaysAssert ); + TDes8& commonMessage = reinterpret_cast( const_cast( aMessage ) ); + SendCommServiceNotIdentifiedResp( commonMessage ); + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage unknown NAMESERVICE message" ) ) ); } } - C_TRACE( ( _T( "DISINameService::HandlePNSNameMessage<" ) ) ); + C_TRACE( ( _T( "DISINameService::HandlePnsNameMessage 0x%x<" ), &aMessage ) ); } - + +void DISINameService::HandleNameAddReq( + const TDesC8& aPnsNameAddReq + ) + { + C_TRACE( ( _T( "DISINameService::HandleNameAddReq 0x%x>" ), &aPnsNameAddReq ) ); + TInt err( KErrArgument ); + TUint16 respMsgLength( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_RESP ); + TDes8& respMsg = MemApi::AllocBlock( respMsgLength ); + respMsg.SetLength( respMsgLength ); + TUint8* respPtr = const_cast( respMsg.Ptr() ); + const TUint8* msgPtr = const_cast( aPnsNameAddReq.Ptr() ); + SetIsiHeaderForResp( respMsg, aPnsNameAddReq, PNS_NAME_ADD_RESP ); + if( msgPtr[ ISI_HEADER_OFFSET_SENDERDEVICE ] == PN_DEV_OWN ) + { + C_TRACE( ( _T( "DISINameService::HandleNameAddReq PNS_NAME_ADD_REQ from this device" ) ) ); + TUint32 name = GETB32( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY ] ); + TUint16 phonetAddr = GETB16( &msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ] ); + TUint8 flags = msgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_REQ_OFFSET_NAMEENTRY + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ]; + err = iNameRecords->AddName( name, phonetAddr, flags ); + respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = err; + SendToRouter( respMsg ); + if( err == PN_NAME_OK ) + { + TxPnsNameAddInd( aPnsNameAddReq, name, phonetAddr, flags ); + } + // No need for else as state is not changed and indication is not needed to send. + } + else + { + C_TRACE( ( _T( "DISINameService::HandleNameAddReq PNS_NAME_ADD_REQ from other device" ) ) ); + respPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_RESP_OFFSET_REASON ] = PN_NAME_NOT_ALLOWED; + SendToRouter( respMsg ); + } + TDes8* block = reinterpret_cast( const_cast(&aPnsNameAddReq) ); + MemApi::DeallocBlock( *block ); + C_TRACE( ( _T( "DISINameService::HandleNameAddReq 0x%x<" ), &aPnsNameAddReq ) ); + } EXPORT_C TBool MISICommunicationManagerIf::IsValidResource( const TDesC8& aMessage ) { - C_TRACE( ( _T( "DISINameService::IsValidResource 0x%x>" ), &aMessage ) ); - TInt err( Kern::MutexWait( *DISINameService::iThisptr->iNameServiceMutex ) ); - ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EISINameServiceMutexWaitFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); - TUint8* msgPtr = const_cast( aMessage.Ptr() ); - TUint16 phonetAddress( 0 ); - DISINameService::iThisptr->iNameRecords->LookupPhonetAddress( msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ], &phonetAddress ); - Kern::MutexSignal( *DISINameService::iThisptr->iNameServiceMutex ); - if( phonetAddress == GET_SENDER_OBJ( aMessage ) ) - { - C_TRACE( ( _T( "DISINameService::IsValidResource phonetAddress found 0x%x" ), phonetAddress ) ); - return ETrue; - } - else - { - C_TRACE( ( _T( "DISINameService::IsValidResource phonetAddress not found 0x%x" ), phonetAddress ) ); - return EFalse; - } + C_TRACE( ( _T( "MISICommunicationManagerIf::IsValidResource 0x%x>" ), &aMessage ) ); + DISINameService* self = DISINameService::GetISINameServiceF(); + TBool found = self->HandleResourceValidationCheck( aMessage ); + C_TRACE( ( _T( "MISICommunicationManagerIf::IsValidResource 0x%x %d<" ), &aMessage, found ) ); + return found; } +EXPORT_C TUint8 MISICommunicationManagerIf::GetDeviceIdentifierByResource( + const TUint32 aResourceIdentifier + ) + { + C_TRACE( ( _T( "MISICommunicationManagerIf::GetDeviceIdentifierByResource 0x%x>" ), aResourceIdentifier ) ); + DISINameService* self = DISINameService::GetISINameServiceF(); + TUint8 deviceIdentifier = self->GetDeviceIdByResource( aResourceIdentifier ); + C_TRACE( ( _T( "MISICommunicationManagerIf::GetDeviceIdentifierByResource 0x%x 0x%x<" ), aResourceIdentifier, deviceIdentifier ) ); + return deviceIdentifier; + } DECLARE_STANDARD_EXTENSION() { @@ -436,7 +426,6 @@ // Create a container extension DISINameService* extension = new DISINameService(); TRACE_ASSERT( extension ); - DISINameService::iThisptr = static_cast< DISINameService* >( extension ); Kern::Printf( "ISI Name Service extension<" ); return extension ? KErrNone : KErrNoMemory; } @@ -445,9 +434,8 @@ const TDesC8& aMsg ) { - C_TRACE( ( _T( "DISINameService::ConstructCommIsaEntityNotReachableResp 0x%x ->" ), &aMsg ) ); + C_TRACE( ( _T( "DISINameService::ConstructCommIsaEntityNotReachableResp 0x%x>" ), &aMsg ) ); // Make channel opening request followinfg COMM specification: 000.026 - // Length is sixteen bytes. TUint8 length( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP ); TDes8& tempPtr = MemApi::AllocBlock( length ); ASSERT_RESET_ALWAYS( &tempPtr, EISINameServiceMemAllocFailure ); //lisää jotakin infoa jotta löytyy ilman tracea...pelkän luvun perusteella?? @@ -464,7 +452,7 @@ SET_LENGTH( ptr, length - PN_HEADER_SIZE ); SET_RECEIVER_OBJ( ptr, GET_SENDER_OBJ( aMsg ) ); SET_SENDER_OBJ( ptr, GET_RECEIVER_OBJ( aMsg ) ); - // Transactionid. Set to 0x01 since this is the first. + // Transactionid. tempPtr.Append( msgTmpPtr[ ISI_HEADER_OFFSET_TRANSID ] ); // Message ID tempPtr.Append( COMMON_MESSAGE ); // 0xF0 @@ -475,18 +463,456 @@ // Status - COMM_ISA_ENTITY_NOT_EXISTING tempPtr.Append( COMM_ISA_ENTITY_NOT_EXISTING); //0x01 // Filler - tempPtr.Append( 0x00 ); + tempPtr.Append( KFiller ); // Filler - tempPtr.Append( 0x00 ); + tempPtr.Append( KFiller ); // Filler - tempPtr.Append( 0x00 ); - + tempPtr.Append( KFiller ); //send data to router for handling - iRouter->Send( tempPtr, iObjId); - + SendToRouter( tempPtr ); TDes8* block = reinterpret_cast( const_cast(&aMsg) ); MemApi::DeallocBlock( *block ); - C_TRACE( ( _T( "DISINameService::SendCommIsaEntityNotReachableResp 0x%x <-" ), &aMsg ) ); + C_TRACE( ( _T( "DISINameService::SendCommIsaEntityNotReachableResp 0x%x<" ), &aMsg ) ); + } + +void DISINameService::HandleCommonMessage( + const TDesC8& aCommonMessage + ) + { + + C_TRACE( ( _T( "DISINameService::HandleCommonMessage 0x%x>" ), &aCommonMessage ) ); + TDes8& commonMessage = reinterpret_cast( const_cast(aCommonMessage) ); + const TUint8 subMessageIdentifier = commonMessage.Ptr()[ ISI_HEADER_OFFSET_SUBMESSAGEID ]; + switch( subMessageIdentifier ) + { + case COMM_ISA_ENTITY_NOT_REACHABLE_RESP: + { + const TUint8 notDeliveredMessageIndex = ( ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP_OFFSET_NOTDELIVEREDMESSAGEID ); + const TUint8 notDeliveredMessageIdentifier = commonMessage.Ptr()[ notDeliveredMessageIndex ]; + // If some of name service _RESP worryig behaviour from client. If _IND it does not matter so much, although unsubscription for indications is not working then. + C_TRACE( ( _T( "DISINameService::HandleCommonMessage COMM_ISA_ENTITY_NOT_REACHABLE_RESP not delivered message 0x%x" ), notDeliveredMessageIdentifier ) ); + TRACE_ASSERT_ALWAYS( KAlwaysAssert ); + // Dellocate here, because this is not sending a reply at all to avoid never ending loop. + MemApi::DeallocBlock( commonMessage ); + // Signal here because it does not send a reply. + FreeNameServiceDMutex(); + break; + } + case COMM_ISI_VERSION_GET_REQ: + { + C_TRACE( ( _T( "DISINameService::HandleCommonMessage version get req" ) ) ); + SendCommIsiVersionGetResp( commonMessage ); + break; + } + default: + { + C_TRACE( ( _T( "DISINameService::HandleCommonMessage unknown common message" ) ) ); + TRACE_ASSERT_ALWAYS( KAlwaysAssert ); + SendCommServiceNotIdentifiedResp( commonMessage ); + break; + } + } + C_TRACE( ( _T( "DISINameService::HandleCommonMessage 0x%x<" ), &aCommonMessage ) ); + } + +void DISINameService::SendCommServiceNotIdentifiedResp( + TDes8& aCommServiceNotIdentifiedReq + ) + { + C_TRACE( ( _T( "DISINameService::SendCommServiceNotIdentifiedResp 0x%x>" ), &aCommServiceNotIdentifiedReq ) ); + TUint8 length( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP ); + TDes8& respMsg = MemApi::AllocBlock( length ); + respMsg.SetLength(ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP ); + TUint8* ptr( const_cast( respMsg.Ptr() ) ); + ASSERT_RESET_ALWAYS( ptr, ( EISINameServiceNullPointer1 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( respMsg.Length() >= (ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE2) ), + ( EISINameServiceWrongLength | EDISINameServiceTraceId << KClassIdentifierShift ) ); + const TUint8* msgPtr( aCommServiceNotIdentifiedReq.Ptr() ); + SetIsiHeaderForCommonResp( respMsg, aCommServiceNotIdentifiedReq ); + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_SUBMESSAGEID ] = COMM_SERVICE_NOT_IDENTIFIED_RESP; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_NOTSERVEDMESSAGEID ] = msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ]; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE1 ] = KFiller;// ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_MESSAGEEXTENSION ] = KNoExtension; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_NOTSERVEDSUBMESSAGEID ] = msgPtr[ ISI_HEADER_OFFSET_SUBMESSAGEID ]; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE1 ] = KFiller; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_FILLERBYTE2 ] = KFiller; + SendToRouter( respMsg ); + MemApi::DeallocBlock( aCommServiceNotIdentifiedReq ); + C_TRACE( ( _T( "DISINameService::SendCommServiceNotIdentifiedResp 0x%x<" ), &aCommServiceNotIdentifiedReq ) ); + } + +void DISINameService::SendCommIsiVersionGetResp( + TDes8& aCommIsiVersionGetReq + ) + { + C_TRACE( ( _T( "DISINameService::SendCommIsiVersionGetResp 0x%x>" ), &aCommIsiVersionGetReq ) ); + TUint8 length( ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP ); + TDes8& respMsg = MemApi::AllocBlock( length ); + respMsg.SetLength(ISI_HEADER_SIZE + SIZE_COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP); + TUint8* ptr( const_cast( respMsg.Ptr() ) ); + ASSERT_RESET_ALWAYS( ptr, ( EISINameServiceNullPointer2 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( respMsg.Length() >= (ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_FILLERBYTE3) ), + ( EISINameServiceWrongLength1 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + const TUint8* msgPtr( aCommIsiVersionGetReq.Ptr() ); + SetIsiHeaderForCommonResp( respMsg, aCommIsiVersionGetReq ); + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_SUBMESSAGEID ] = COMM_ISI_VERSION_GET_RESP; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_ISIVERSIONZZZ ] = NAME_SERVICE_ISI_VERSION_Z; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_ISIVERSIONYYY ] = NAME_SERVICE_ISI_VERSION_Y; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_FILLERBYTE1 ] = KFiller; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_FILLERBYTE2 ] = KFiller; + ptr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_ISI_VERSION_GET_RESP_OFFSET_FILLERBYTE3 ] = KFiller; + SendToRouter( respMsg ); + MemApi::DeallocBlock( aCommIsiVersionGetReq ); + C_TRACE( ( _T( "DISINameService::SendCommIsiVersionGetResp 0x%x<" ), &aCommIsiVersionGetReq ) ); + } + +void DISINameService::LockNameServiceDMutex() + { + C_TRACE( ( _T( "DISINameService::LockNameServiceDMutex 0x%x>" ), &iNameServiceMutex ) ); + TInt err( Kern::MutexWait( *iNameServiceMutex ) ); + ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EISINameServiceMutexWaitFailed | EDISINameServiceTraceId << KClassIdentifierShift ) ); + C_TRACE( ( _T( "DISINameService::LockNameServiceDMutex 0x%x<" ), &iNameServiceMutex ) ); + } + +void DISINameService::FreeNameServiceDMutex() + { + C_TRACE( ( _T( "DISINameService::FreeNameServiceDMutex 0x%x>" ), &iNameServiceMutex ) ); + Kern::MutexSignal( *iNameServiceMutex ); + C_TRACE( ( _T( "DISINameService::FreeNameServiceDMutex 0x%x<" ), &iNameServiceMutex ) ); + } + +TBool DISINameService::HandleResourceValidationCheck( + const TDesC8& aMessage + ) + { + C_TRACE( ( _T( "DISINameService::HandleResourceValidationCheck 0x%x>" ), &aMessage ) ); + LockNameServiceDMutex(); + TUint8* msgPtr = const_cast( aMessage.Ptr() ); + TUint16 phonetAddress( KUninitializedPhoNetAddress ); + // Extended resource identifier support for NameService + TUint32 resource = GetResourceUsedInMessage( aMessage ); + iNameRecords->LookupPhonetAddress( resource, &phonetAddress ); + FreeNameServiceDMutex(); + TBool found( EFalse ); + TUint16 phonetAddressFromMsg = ( ( GET_SENDER_DEV( msgPtr ) << KDeviceIdentifierPhoNetAddressShift ) | GET_SENDER_OBJ( msgPtr ) ); + if( phonetAddress == phonetAddressFromMsg ) + { + C_TRACE( ( _T( "DISINameService::IsValidResource phonetAddress found 0x%x" ), phonetAddress ) ); + found = ETrue; + } + // No need for else, assert tells that somebody violates indication sending + TRACE_ASSERT( found ); + C_TRACE( ( _T( "DISINameService::HandleResourceValidationCheck 0x%x %d<" ), &aMessage, found ) ); + return found; + } + +// Extended resource identifier support for NameService +TUint32 DISINameService::GetResourceUsedInMessage( + const TDesC8& aMessageToBeResourceRouted + ) + { + C_TRACE( ( _T( "DISINameService::GetResourceUsedInMessage 0x%x>" ), &aMessageToBeResourceRouted ) ); + const TUint8* msgPtr( aMessageToBeResourceRouted.Ptr() ); + ASSERT_RESET_ALWAYS( ( msgPtr ), + ( EISINameServiceNullPointer11 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint32 resource = msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ]; +#ifdef ISCE_INTERNAL_EXTENDED_RESOURCE_ROUTING_SUPPORTED + // Extended Resource Routing + if( PN_PREFIX == msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] ) + { + C_TRACE( ( _T( "DISINameService::GetResourceUsedInMessage 0x%x extended resource 0x%x" ), &aMessageToBeResourceRouted, resource ) ); + resource = ( resource | (TUint32)( msgPtr[ ISI_HEADER_OFFSET_TYPE ] << KEightBitShift ) ); + resource = ( resource | (TUint32)( msgPtr[ ISI_HEADER_OFFSET_SUBTYPE ] << KSixteenBitShift ) ); + } + +#endif // ISCE_INTERNAL_EXTENDED_RESOURCE_ROUTING_SUPPORTED + // No need for else as first 8 bits are already used. + C_TRACE( ( _T( "DISINameService::GetResourceUsedInMessage 0x%x resource 0x%x<" ), &aMessageToBeResourceRouted, resource ) ); + return resource; + } + +TUint8 DISINameService::GetDeviceIdByResource( + const TUint32 aResourceIdentifier + ) + { + C_TRACE( ( _T( "DISINameService::GetDeviceIdByResource 0x%x>" ), aResourceIdentifier ) ); + TUint8 deviceIdentifier = PN_DEV_OWN; +#ifdef ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + C_TRACE( ( _T( "DISINameService::GetDeviceIdByResource 0x%x ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE" ), aResourceIdentifier ) ); + LockNameServiceDMutex(); + TUint16 phonetAddress( KUninitializedPhoNetAddress ); + TUint32 result = iNameRecords->LookupPhonetAddress( aResourceIdentifier, &phonetAddress ); + FreeNameServiceDMutex(); + if( result == KErrNone ) + { + C_TRACE( ( _T( "DISINameService::GetDeviceIdByResource 0x%x old device 0x%x phonetAddress 0x%x" ), aResourceIdentifier, deviceIdentifier, phonetAddress ) ); + deviceIdentifier = ( (TUint8)( phonetAddress >> KEightBitShift ) ); + C_TRACE( ( _T( "DISINameService::GetDeviceIdByResource 0x%x new device 0x%x phonetAddress 0x%x" ), aResourceIdentifier, deviceIdentifier, phonetAddress ) ); + } +#endif // ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + // No need for else as going to default + C_TRACE( ( _T( "DISINameService::GetDeviceIdByResource 0x%x 0x%x<" ), aResourceIdentifier, deviceIdentifier ) ); + return deviceIdentifier; + } + +void DISINameService::TxPnsNameAddInd( + const TDesC8& aPnsNameAddReq, + const TUint32 aName, + const TUint16 aPhoNetAddress, + const TUint8 aFlags + ) + { + C_TRACE( ( _T( "DISINameService::TxPnsNameAddInd 0x%x>" ), &aPnsNameAddReq ) ); + LockNameServiceDMutex(); + const TUint8* msgPtr( aPnsNameAddReq.Ptr() ); + ASSERT_RESET_ALWAYS( msgPtr, + ( EISINameServiceNullPointer13 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint32 msgLength = ( ISI_HEADER_SIZE + SIZE_PNS_NAME_ADD_IND ); + TDes8& indMsg = MemApi::AllocBlock( msgLength ); + indMsg.SetLength( msgLength ); + ASSERT_RESET_ALWAYS( ( indMsg.Length() > ( ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ) ), + ( EISINameServiceWrongLength8 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint8* indPtr = const_cast( indMsg.Ptr() ); + SetIsiHeaderForIndication( indMsg, aPnsNameAddReq, PNS_NAME_ADD_IND ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_TOTALMATCHES ], KOneMatch ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_MATCHESINMSG ], KOneMatch ); + indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_RESERVED1 ] = KFiller; + indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_RESERVED2 ] = KFiller; + PUTB32( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ], aName ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ], aPhoNetAddress ); + indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = aFlags; + indPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_RESERVED ] = KFiller; + SendToRouter( indMsg ); + + C_TRACE( ( _T( "DISINameService::TxPnsNameAddInd 0x%x<" ), &aPnsNameAddReq ) ); } +void DISINameService::TxPnsNameRemoveInd( + const TDesC8& aPnsNameRemoveReq, + const TUint32 aName, + const TUint16 aPhoNetAddress, + const TUint8 aFlags + ) + { + C_TRACE( ( _T( "DISINameService::TxPnsNameRemoveInd 0x%x>" ), &aPnsNameRemoveReq ) ); + LockNameServiceDMutex(); + const TUint8* msgPtr( aPnsNameRemoveReq.Ptr() ); + ASSERT_RESET_ALWAYS( msgPtr, + ( EISINameServiceNullPointer14 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint32 msgLength = ( ISI_HEADER_SIZE + SIZE_PNS_NAME_REMOVE_IND ); + TDes8& indMsg = MemApi::AllocBlock( msgLength ); + indMsg.SetLength( msgLength ); + ASSERT_RESET_ALWAYS( ( indMsg.Length() > ( ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ) ), + ( EISINameServiceWrongLength8 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint8* indPtr = const_cast( indMsg.Ptr() ); + ASSERT_RESET_ALWAYS( indPtr, ( EISINameServiceNullPointer10 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + SetIsiHeaderForIndication( indMsg, aPnsNameRemoveReq, PNS_NAME_REMOVE_IND ); + C_TRACE( ( _T( "DISINameService::TxPnsNameRemoveInd 0x%x name 0x%x phonetAddress 0x%x flags 0x%x" ), &aPnsNameRemoveReq, aName, aPhoNetAddress, aFlags ) ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_TOTALMATCHES ], KOneMatch ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_MATCHESINMSG ], KOneMatch ); + indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_RESERVED1 ] = KFiller; + indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_RESERVED2 ] = KFiller; + PUTB32( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_NAME ], aName ); + PUTB16( &indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_DEV ], aPhoNetAddress ); + indPtr[ ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL + PN_NAME_SRV_ITEM_STR_OFFSET_FLAGS ] = aFlags; + SendToRouter( indMsg ); + C_TRACE( ( _T( "DISINameService::TxPnsNameRemoveInd 0x%x<" ), &aPnsNameRemoveReq ) ); + } +DISINameService* DISINameService::GetISINameServiceF( + // None + ) + { + ASSERT_RESET_ALWAYS( iThisptr, + ( EISINameServiceNullPointer12 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + return iThisptr; + } + +DNameRecords* DISINameService::GetNameRecordsF( + // None + ) + { + ASSERT_RESET_ALWAYS( iNameRecords, + ( EISINameServiceNullPointer15 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + return iNameRecords; + } + +void DISINameService::SetIsiHeaderForResp( + const TDesC8& aResponseMessage, + const TDesC8& aRequestMessage, + const TUint8 aResponseMessageIdentifier + ) + { + C_TRACE( ( _T( "DISINameService::SetIsiHeaderForResp 0x%x 0x%x 0x%x>" ), &aResponseMessage, &aRequestMessage, aResponseMessageIdentifier ) ); + const TUint8* reqMsgPtr = aRequestMessage.Ptr(); + ASSERT_RESET_ALWAYS( reqMsgPtr, ( EISINameServiceNullPointer16 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint8* respMsgPtr = const_cast( aResponseMessage.Ptr() ); + ASSERT_RESET_ALWAYS( respMsgPtr, ( EISINameServiceNullPointer17 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aResponseMessage.Length() > ISI_HEADER_OFFSET_MESSAGEID ), + ( EISINameServiceWrongLength9 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aRequestMessage.Length() > ISI_HEADER_OFFSET_TRANSID ), + ( EISINameServiceWrongLength10 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + respMsgPtr[ ISI_HEADER_OFFSET_MEDIA ] = reqMsgPtr[ ISI_HEADER_OFFSET_MEDIA ]; + SET_RECEIVER_DEV( respMsgPtr, GET_SENDER_DEV( reqMsgPtr ) ); + SET_SENDER_DEV( respMsgPtr, PN_DEV_OWN ); + respMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; + SET_LENGTH( respMsgPtr, ( aResponseMessage.Length() - PN_HEADER_SIZE ) ); + SET_RECEIVER_OBJ( respMsgPtr, GET_SENDER_OBJ( reqMsgPtr ) ); + SET_SENDER_OBJ( respMsgPtr, PN_OBJ_ROUTER ); + respMsgPtr[ ISI_HEADER_OFFSET_TRANSID ] = reqMsgPtr[ ISI_HEADER_OFFSET_TRANSID ]; + respMsgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] = aResponseMessageIdentifier; + C_TRACE( ( _T( "DISINameService::SetIsiHeaderForResp 0x%x 0x%x 0x%x<" ), &aResponseMessage, &aRequestMessage, aResponseMessageIdentifier ) ); + } + +void DISINameService::SetIsiHeaderForCommonResp( + const TDesC8& aResponseMessage, + const TDesC8& aRequestMessage + ) + { + C_TRACE( ( _T( "DISINameService::SetIsiHeaderForCommonResp 0x%x 0x%x>" ), &aResponseMessage, &aRequestMessage ) ); + const TUint8* reqMsgPtr = aRequestMessage.Ptr(); + ASSERT_RESET_ALWAYS( reqMsgPtr, ( EISINameServiceNullPointer18 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint8* respMsgPtr = const_cast( aResponseMessage.Ptr() ); + ASSERT_RESET_ALWAYS( respMsgPtr, ( EISINameServiceNullPointer19 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aResponseMessage.Length() > ISI_HEADER_OFFSET_MESSAGEID ), + ( EISINameServiceWrongLength11 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aRequestMessage.Length() > ISI_HEADER_OFFSET_TRANSID ), + ( EISINameServiceWrongLength12 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + respMsgPtr[ ISI_HEADER_OFFSET_MEDIA ] = ( reqMsgPtr[ ISI_HEADER_OFFSET_MEDIA ] ); + SET_RECEIVER_DEV( respMsgPtr, GET_SENDER_DEV( reqMsgPtr ) ); + SET_SENDER_DEV( respMsgPtr, PN_DEV_OWN ); + respMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = ( reqMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] ); + SET_LENGTH( respMsgPtr, ( aResponseMessage.Length() - PN_HEADER_SIZE ) ); + SET_RECEIVER_OBJ( respMsgPtr, GET_SENDER_OBJ( reqMsgPtr ) ); + SET_SENDER_OBJ( respMsgPtr, GET_RECEIVER_OBJ( reqMsgPtr ) ); + respMsgPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_TRANSACTIONID ] = ( reqMsgPtr[ ISI_HEADER_OFFSET_TRANSID ] ); + respMsgPtr[ ISI_HEADER_SIZE + COMMON_MESSAGE_COMM_SERVICE_NOT_IDENTIFIED_RESP_OFFSET_MESSAGEID ] = COMMON_MESSAGE; + C_TRACE( ( _T( "DISINameService::SetIsiHeaderForCommonResp 0x%x 0x%x<" ), &aResponseMessage, &aRequestMessage ) ); + } + +void DISINameService::SetIsiHeaderForIndication( + const TDesC8& aIndicationToModify, + const TDesC8& aPnsNameRequest, + const TUint8 aIndicationMessageIdentifier + ) + { + C_TRACE( ( _T( "DISINameService::aIndicationToModify 0x%x 0x%x 0x%x>" ), &aIndicationToModify, &aPnsNameRequest, aIndicationMessageIdentifier ) ); + const TUint8* reqMsgPtr = aPnsNameRequest.Ptr(); + ASSERT_RESET_ALWAYS( reqMsgPtr, ( EISINameServiceNullPointer18 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + TUint8* indMsgPtr = const_cast( aIndicationToModify.Ptr() ); + ASSERT_RESET_ALWAYS( indMsgPtr, ( EISINameServiceNullPointer19 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aIndicationToModify.Length() > ISI_HEADER_OFFSET_MESSAGEID ), + ( EISINameServiceWrongLength11 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + ASSERT_RESET_ALWAYS( ( aPnsNameRequest.Length() > ISI_HEADER_OFFSET_TRANSID ), + ( EISINameServiceWrongLength12 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + indMsgPtr[ ISI_HEADER_OFFSET_MEDIA ] = PN_MEDIA_ROUTING_REQ; + SET_RECEIVER_DEV( indMsgPtr, GET_SENDER_DEV( reqMsgPtr ) ); + SET_SENDER_DEV( indMsgPtr, PN_DEV_OWN ); + indMsgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_NAMESERVICE; + SET_LENGTH( indMsgPtr, ( aIndicationToModify.Length() - PN_HEADER_SIZE ) ); + SET_RECEIVER_OBJ( indMsgPtr, PN_OBJ_EVENT_MULTICAST ); + SET_SENDER_OBJ( indMsgPtr, PN_OBJ_ROUTER ); + indMsgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_UTID ] = 0x00; + indMsgPtr[ ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_SUBFUNCTION ]= aIndicationMessageIdentifier; + C_TRACE( ( _T( "DISINameService::aIndicationToModify 0x%x 0x%x 0x%x<" ), &aIndicationToModify, &aPnsNameRequest, aIndicationMessageIdentifier ) ); + } +DISINameServiceExtended::DISINameServiceExtended( + DISINameService* aNameService + ) + { + C_TRACE( ( _T( "DISINameServiceExtended::DISINameServiceExtended 0x%x>" ), iISINameService ) ); + iISINameService = aNameService; + ASSERT_RESET_ALWAYS( iISINameService, ( EISINameServiceExtendedNullPointer | EDISINameServiceTraceId << KClassIdentifierShift ) ); + AddModemResources(); + //AddPnDevDspMainResources(); + // iShNameAddIndSubscriptionState = ENotSubscribed; + + // + // flag: ISCE_INTERNAL_WIDER_NAME_SERVICE_IN_USE + // + // + // - Extended Resource routing supported by Symbian SW Name Service (Design Change) + // - PN_COMMGR by default routed to RAPU, by device id 0x6c routed to Symbian SW PN_COMMGR (Design Change) + // - Internally in ISCE PN_COMMGR name is handled : [0] PN_COMMGR, [1] deviceidentifier, [2] don't care, [3] don't care only visible in NameRecords table + // - PN_NAMESERVICE by default routed to RAPU by device id 0x6c routed to Symbian SW PN_NAMESERVICE + // - Symbian SW wider name service subscribes PNS_NAME_ADD_INDs from RAPU through Symbian SW PN_APE_COMMGR (REQ, RESP) + // - Symbian SW Name Service contains: Symbian SW Resources added with PNS_NAME_ADD_REQ dev id PN_DEV_OWN (Phonet address 0x6c[own for all], TD MODEM Resources (Phonet address 0x6000), PN_DSP_MAIN, Symbian SW Resource stored in RAPU Name Service (dynamically added after PNS_NAME_ADD_IND received PhoNet address as got from indication), other messages are routed to RAPU (Design Change) + // - Communication Manager calls ::GetDeviceIdentifierByResouce to get appropriate device identifier to indication subscription + // + // worry later the usage of shared resource such as PN_COMMGR, PN_NAME_SERVICE etc.. others that shall pop up due to missing ISA system design, use rxdev from message vs. nametable entry to differentiate them + + C_TRACE( ( _T( "DISINameServiceExtended::DISINameServiceExtended 0x%x<" ), iISINameService ) ); + } + +DISINameServiceExtended::~DISINameServiceExtended( + // None + ) + { + C_TRACE( ( _T( "DISINameServiceExtended::~DISINameServiceExtended<>" ) ) ); + } +void DISINameServiceExtended::AddModemResources( + // None + ) + { + C_TRACE( ( _T( "DISINameServiceExtended::AddModemResources>" ) ) ); + TUint8 err( PN_NAME_OK ); + TUint8 flags = PN_NAME_NOCHG; + TUint16 phonetAddressModemRoutingReq = ( ( PN_DEV_MODEM << KDeviceIdentifierPhoNetAddressShift ) | PN_OBJ_ROUTING_REQ ); + + DNameRecords* nameRecords = iISINameService->GetNameRecordsF(); + + err = nameRecords->AddName( PN_SMS, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed1 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_SS, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed2 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_CSD, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed3 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_GPDS, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed4 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_GSS, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed5 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_UICC, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed6 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_AT_MODEM, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed7 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_LCS, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed8 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_TEST, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed9 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_NVD, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed10 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_MCE, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed11 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_INFO, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed12 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_NETWORK, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed13 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_MODEM_CALL, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed14 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_WCDMA_RF_TEST, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed15 | EDISINameServiceTraceId << KClassIdentifierShift ) ); // EISINameServiceNameCreateFailed15... + + err = nameRecords->AddName( PN_GSM_RF_TEST, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed16 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_RF_HAL, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed17 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + err = nameRecords->AddName( PN_COMMON_RF_TEST, phonetAddressModemRoutingReq, flags ); + ASSERT_RESET_ALWAYS( ( PN_NAME_OK == err ), ( EISINameServiceNameCreateFailed18 | EDISINameServiceTraceId << KClassIdentifierShift ) ); + + C_TRACE( ( _T( "DISINameServiceExtended::AddModemResources<" ) ) ); + }