FCL/sf/incubator/modemadaptation: comparison adaptationlayer/tsy/nokiatsy

equal deleted inserted replaced

-:6295dc2169f3
+:8486d82aef45
 /*
-* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 //  EXTERNAL RESOURCES
 //  Include Files
 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>
 #include <ctsy/pluginapi/cmmdatapackage.h>
-// Temporarily removed for Bridge camp!
+#include <ctsy/serviceapi/ctsysatmessagingbase.h>
-//#include <ctsy/serviceapi/ctsysatmessagingbase.h>
 #include <etelsat.h>  // for sat mo sm control error values
 #include <ctsy/serviceapi/gsmerror.h> // for sat mo sm control error values
 #include <etelmmerr.h>
 #include <tisi.h>
 #include <smsisi.h>
 #include "cmmstaticutility.h"
 #include "cmmmessagerouter.h"
 #include "cmmphonemesshandler.h"
 #include "tsylogger.h"
 #include "cmmphonetsender.h"
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "cmmsmsmesshandlerTraces.h"
 #endif
 const TUint8 KSmsParamsProtocolIdOffset( 25 );
 const TUint8 KSmsParamsDcsOffset( 26 );
 const TUint8 KSmsParamsValidityPeriodOffset( 27 );
 const TUint8 KSizeOfAlphaTag( 62 );
+const TUint8 KShift8( 8 );
+const TUint16 KSmsResIdMoSmInitDisable( 0 ); // SMS_RES_ID_MO_SM_INIT_DISABLE
 //  MODULE DATA STRUCTURES
 //  Local Data Structures
 //  none
 // -----------------------------------------------------------------------------
 //
 CMmSmsMessHandler::CMmSmsMessHandler()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::CMmSmsMessHandler: constructor.");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_CMMSMSMESSHANDLER, "CMmSmsMessHandler::CMmSmsMessHandler" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_CMMSMSMESSHANDLER_TD, "CMmSmsMessHandler::CMmSmsMessHandler" );
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::CMmSmsMessHandler
 // C++ default destructor
 // -----------------------------------------------------------------------------
 //
 CMmSmsMessHandler::~CMmSmsMessHandler()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::CMmSmsMessHandler: destructor.");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CMMSMSMESSHANDLER, "CMmSmsMessHandler::~CMmSmsMessHandler" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_CMMSMSMESSHANDLER_TD, "CMmSmsMessHandler::~CMmSmsMessHandler" );
 // Delete arrays
 if( iSmsListArray )
 {
 iSmsListArray->ResetAndDestroy();
 delete iSmsListArray;
 CMmMessageRouter* aMessageRouter,    // pointer to Message router
 CMmUiccMessHandler* aUiccMessHandler // pointer to UICC message handler
 )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::NewL");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_NEWL, "CMmSmsMessHandler::NewL" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_NEWL_TD, "CMmSmsMessHandler::NewL" );
 CMmSmsMessHandler* smsMessHandler = new ( ELeave ) CMmSmsMessHandler();
 CleanupStack::PushL( smsMessHandler );
 smsMessHandler->iPhoNetSender = aPhoNetSender;
+smsMessHandler->iPhonetReceiver = aPhoNetReceiver;
 smsMessHandler->iMessageRouter = aMessageRouter;
 smsMessHandler->iMmUiccMessHandler = aUiccMessHandler;
 smsMessHandler->ConstructL();
 aPhoNetReceiver->RegisterL( smsMessHandler, PN_SMS );
 CleanupStack::Pop( smsMessHandler );
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::ConstructL()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ConstructL");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_CONSTRUCTL, "CMmSmsMessHandler::ConstructL" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_CONSTRUCTL_TD, "CMmSmsMessHandler::ConstructL" );
 iSmsListArray = new ( ELeave ) CArrayPtrFlat<TSmsMsg>( 1 );
 iSmspListArray = new ( ELeave ) CArrayPtrFlat<TSmsParameters>( 1 );
 iReceivedClass2ToBeReSent = EFalse;
 // default bearer setting is "CS preferred"
 iMobileSmsBearer = RMobileSmsMessaging::ESmsBearerCircuitPreferred;
-iMemoryCapacityExceeded = EFalse;
 // Reading of SMSP entries starts from record 1
 iSmspRecordNumber = 1;
 }
 // -----------------------------------------------------------------------------
 {
 TUint8 resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 TUint8 messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 TFLOGSTRING3("TSY: CMmSmsMessHandler::ReceiveMessageL - resource: %d, msgId: %d", resource, messageId);
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_RECEIVEMESSAGEL,"CMmSmsMessHandler::ReceiveMessageL;resource=%hhu;messageId=%hhu", resource, messageId );
+OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_RECEIVEMESSAGEL_TD,"CMmSmsMessHandler::ReceiveMessageL;resource=%hhu;messageId=%hhu", resource, messageId );
 switch ( resource )
 {
 case PN_SMS:
 {
 EMmTsySmsSendSatMessage );
 }
 else
 {
 TFLOGSTRING2("TSY:CMmSmsMessHandler::ReceiveMessageL:Unexpected transId=%d in SMS_MESSAGE_SEND_RESP.",traId);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;traId=%hhu", traId );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmSmsMessHandler::ReceiveMessageL;traId=%hhu", traId );
 }
 break;
 }
 case SMS_RECEIVE_MESSAGE_RESP:
 {
 case SMS_SETTINGS_UPDATE_RESP :
 {
 SmsSettingsUpdateResp( aIsiMessage );
 break;
 }
+case SMS_RESOURCE_CONF_IND:
+{
+	  SmsResourceConfInd( aIsiMessage );
+	  break;
+}
 default:
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::ReceiveMessageL - PN_SMS - unknown msgId: %d", messageId);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;messageId=%hhu", messageId );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmSmsMessHandler::ReceiveMessageL;messageId=%hhu", messageId );
 // No handler methods for ISI-message found.
 break;
 }
 }
 break;
 }
 default:
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::ReceiveMessageL - unknown resource: %d", resource);
-OstTraceExt1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_RECEIVEMESSAGEL, "CMmSmsMessHandler::ReceiveMessageL;resource=%hhu", resource );
+OstTraceExt1( TRACE_NORMAL,  DUP6_CMMSMSMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmSmsMessHandler::ReceiveMessageL;resource=%hhu", resource );
 // No handler methods for ISI-message found.
 break;
 }
 }
 }
 TBool aSmsCheckDisableFdn )         // Add SMS_SB_CHECK_INFO with
 // SMS_CHECK_DISABLE_FDN
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Transaction ID: %d", aTransactionId);
-OstTraceExt1( TRACE_NORMAL,DUP18_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ,"CMmSmsMessHandler::SmsMessageSendReq;aTransactionId=%hhu", aTransactionId );
+OstTraceExt1( TRACE_NORMAL,DUP18_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ_TD,"CMmSmsMessHandler::SmsMessageSendReq;aTransactionId=%hhu", aTransactionId );
 TInt ret( KErrNone );
 TUint8 subBlockId( 0 );
 // Structure for all SMS parameters and user data
 {
 ret = CMmStaticUtility::EpocErrorCode(
 KErrArgument,
 KErrGsmSMSTpduNotSupported );
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! SMS type not supported: %d", tpMti);
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error! SMS type not supported;tpMti=%hhu", tpMti );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::SmsMessageSendReq.Error! SMS type not supported;tpMti=%hhu", tpMti );
 }
 }
 else
 {
 // TPDU too long
 ret = CMmStaticUtility::EpocErrorCode(
 KErrArgument,
 KErrGsmSMSTpduNotSupported );
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! TPDU too long: %d", sendData.iMsgData->Length());
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error! TPDU too long;sendData.iMsgData->Length()=%d", sendData.iMsgData->Length() );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::SmsMessageSendReq.Error! TPDU too long;sendData.iMsgData->Length()=%d", sendData.iMsgData->Length() );
 }
 // Check the format of TPDU and data buffer
 if ( ! ( RMobileSmsMessaging::KSmsDataFormat & msgAttr->iFlags &&
 RMobileSmsMessaging::EFormatGsmTpdu & msgAttr->iDataFormat ) )
 {
 ret = CMmStaticUtility::EpocErrorCode(
 KErrArgument,
 KErrGsmSMSTpduNotSupported );
 TFLOGSTRING3("TSY: CMmSmsMessHandler::SmsMessageSendReq. Error! Invalid TPDU format (%d) or data buffer format (%d)", msgAttr->iFlags, msgAttr->iDataFormat );
-OstTraceExt2( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq.Error!;msgAttr->iFlags=%d;msgAttr->iDataFormat=%hhu", msgAttr->iFlags, msgAttr->iDataFormat );
+OstTraceExt2( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::SmsMessageSendReq.Error!;msgAttr->iFlags=%d;msgAttr->iDataFormat=%hhu", msgAttr->iFlags, msgAttr->iDataFormat );
 }
 #if (NCP_COMMON_S60_VERSION_SUPPORT>S60_VERSION_32)
 // Check whether there is SMS sending ongoing.
 if ( iSMSSendingOngoing )
 {
 ret = KErrServerBusy;
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsMessageSendReq. SMS sending failed, server busy!" );
-OstTrace0( TRACE_NORMAL, DUP17_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ, "CMmSmsMessHandler::SmsMessageSendReq. SMS sending failed, server busy!" );
+OstTrace0( TRACE_NORMAL,  DUP17_CMMSMSMESSHANDLER_SMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::SmsMessageSendReq. SMS sending failed, server busy!" );
 }
 #endif // NCP_COMMON_S60_VERSION_SUPPORT
 if ( KErrNone == ret )
 {
 //  |- SMS_SB_ADDRESS (service center address, mandatory, max. 20 bytes)
 //  |
 //  |- SMS_SB_USER_DATA (optional, max. 174 bytes)
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. Subblock ID: %d", aSubblockId);
-OstTraceExt1( TRACE_NORMAL, DUP9_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;aSubblockId=%hhu", aSubblockId );
+OstTraceExt1( TRACE_NORMAL,  DUP9_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq;aSubblockId=%hhu", aSubblockId );
 TInt ret( KErrNone );
 TUint8 addressLength( 0 );
 ret = GetDestAddressLength( aMsgData, aSubblockId, addressLength );
 {
 TUint8 moreMsgToSend( 0 );
 TUint8 smsRoute( SMS_ROUTE_DEFAULT );
 TUint8 tpVpLength( 0 );
 TUint8 tpVpf( 0 );
-TUint8 tpVpSubblockLength( SIZE_SMS_SB_VALIDITY_PERIOD );
 TUint8 tpUdl( 0 );
 TUint8 tpUserDataLengthIndex( KTpduSubmitIndexUserDataLengthIfNoTpVp );
 TUint8 tpUserDataIndex( 0 );
 TUint8 tpDaIndex( KTpduSubmitIndexDestinationAddressLength );
 TUint8 tpDcs( 0 );
 TUint8 msgOffset( ISI_HEADER_SIZE + SIZE_SMS_MESSAGE_SEND_REQ );
 TUint8 numOfSubblocks( 3 ); // 3 mandatory subblocks
-TUint8 lengthOfAddressSb( 0 );
-TUint8 lengthOfSMSUserDataSb( 0 );
 TBool defaultAlphabet( EFalse ); // Data coding type, true if 7-bit
 // Check if more to send parameter is included
 if ( RMobileSmsMessaging::KMoreToSend & aMsgAttr->iFlags )
 {
 0 );
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_MESSAGE_SEND_REQ created. Message offset: %d", msgOffset );
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. More messages to be sent: %d", moreMsgToSend);
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS route: %d", smsRoute);
-OstTraceExt3( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;msgOffset=%hhu;moreMsgToSend=%hhu;smsRoute=%hhu", msgOffset, moreMsgToSend, smsRoute );
+OstTraceExt3( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq;msgOffset=%hhu;moreMsgToSend=%hhu;smsRoute=%hhu", msgOffset, moreMsgToSend, smsRoute );
 // Create SMS_SB_SUBMIT subblock
 if ( SMS_SB_SUBMIT == aSubblockId )
 {
-BuildSmsSbSubmit( aMsgData, isiMsg, msgOffset, addressLength );
+msgOffset += BuildSmsSbSubmit( aMsgData, isiMsg, addressLength, msgOffset );
-msgOffset += SIZE_SMS_SB_SUBMIT;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_SUBMIT created. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_SUBMIT created.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_SUBMIT created.;msgOffset=%hhu", msgOffset );
 // Set needed TPDU index values that depends on SMS type, VP existence
 // and destination address length. Those parameters are needed when
 // creating subblocks SMS_DESTINATION_ADDRESS, SMS_SB_VALIDITY_PERIOD
 // and SMS_SB_USER_DATA.
 // TP-VPF is LSB bits 3 and 4 from the first octect of TPDU
 }
 // Absolute or enhanced format, subblock length is 12
 else
 {
 tpVpLength = SMS_VPF_ABSOLUTE_OR_ENHANCED;
-tpVpSubblockLength = 12;
 tpUserDataLengthIndex =
 KTpduSubmitIndexUserDataLengthVpfAbsoluteEnchanced;
 }
 }
 // No else. If no TP-VP, User data length index was set to
 // 'KTpduSubmitIndexUserDataLengthIfNoTpVp' by default
 }
 else // Create SMS_SB_COMMAND subblock
 {
-BuildSmsSbCommand( aMsgData, isiMsg, msgOffset );
+msgOffset += BuildSmsSbCommand( aMsgData, isiMsg, msgOffset );
-msgOffset += SIZE_SMS_SB_COMMAND;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_COMMAND created. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_COMMAND created.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_COMMAND created.;msgOffset=%hhu", msgOffset );
 tpDaIndex = KTpduCommandIndexDestinationAddressLength;
 tpUserDataLengthIndex = KTpduCommandIndexUserDataLength;
 }
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. Validity period format: %d", tpVpf);
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. User data length index: %d", tpUserDataLengthIndex);
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;tpVpf=%hhu;tpUserDataLengthIndex=%hhu", tpVpf, tpUserDataLengthIndex );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq;tpVpf=%hhu;tpUserDataLengthIndex=%hhu", tpVpf, tpUserDataLengthIndex );
 // Create SMS_SB_ADDRESS subblock for destination address
 // TP-DA length = Length (1 byte) + TON/NPI (1 byte) + address data
 TPtrC8 addressData( aMsgData.Mid( tpDaIndex, ( addressLength + 2 ) ) );
-lengthOfAddressSb = BuildSmsSbAddress(
+msgOffset += BuildSmsSbAddress(
 addressData,
 isiMsg,
 SMS_DESTINATION_ADDRESS,
 msgOffset );
-msgOffset += lengthOfAddressSb;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_ADDRESS created for destination address. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_ADDRESS created for destination address.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_ADDRESS created for destination address.;msgOffset=%hhu", msgOffset );
 // Create SMS_SB_ADDRESS subblock for service center address
 TBuf8<SMS_ADDRESS_MAX_LEN> scAddr;
 BuildScAddress( aMsgAttr->iGsmServiceCentre, scAddr );
-lengthOfAddressSb =
+msgOffset +=
 BuildSmsSbAddress( scAddr, isiMsg, SMS_SMSC_ADDRESS, msgOffset );
-msgOffset += lengthOfAddressSb;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_ADDRESS created for SC address. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP5_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_SB_ADDRESS created for SC address.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP5_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_SB_ADDRESS created for SC address.;msgOffset=%hhu", msgOffset );
 // Create SMS_SB_VALIDITY_PERIOD subblock (optional, used only in
 // case of SMS_SB_SUBMIT)
 if ( SMS_SB_SUBMIT == aSubblockId && tpVpf )
 {
 TUint8 tpVpIndex(
 KTpduSubmitIndexValidityperiod + addressLength );
-BuildSmsSbValidityPeriod(
+msgOffset += BuildSmsSbValidityPeriod(
 aMsgData,
 isiMsg,
 tpVpIndex,
 tpVpLength,
 msgOffset );
-// Udate message offset according to validity period length
-msgOffset += tpVpSubblockLength;
 numOfSubblocks++;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_VALIDITY_PERIOD created. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_SB_VALIDITY_PERIOD created.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP6_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_SB_VALIDITY_PERIOD created.;msgOffset=%hhu", msgOffset );
 }
 // Create SMS_SB_USER_DATA subblock if user data exists
 // Destination address length must be added to get user data
 // length index
 tpUserDataLengthIndex += addressLength;
 tpUdl = aMsgData[tpUserDataLengthIndex];
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. User data length from TPDU: %d", tpUdl);
-OstTrace1( TRACE_NORMAL, DUP10_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq;tpUdl=%d", tpUdl );
+OstTrace1( TRACE_NORMAL,  DUP10_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq;tpUdl=%d", tpUdl );
 if ( tpUdl )
 {
 // Actual user data is next index from TP-UDL position
 tpUserDataIndex = tpUserDataLengthIndex + 1;
 if ( SMS_SB_SUBMIT == aSubblockId )
 {
 tpDcs = aMsgData[ KTpduSubmitIndexDataCodingScheme + addressLength ];
 defaultAlphabet = IsDataCodingScheme7Bit( tpDcs );
 }
-lengthOfSMSUserDataSb = BuildSmsSbUserData(
+msgOffset += BuildSmsSbUserData(
 aMsgData,
 isiMsg,
 tpUdl,
 tpUserDataIndex,
 defaultAlphabet,
 msgOffset );
 numOfSubblocks++;
-msgOffset += lengthOfSMSUserDataSb;
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_USER_DATA created. Message offset: %d", msgOffset );
-OstTraceExt1( TRACE_NORMAL, DUP7_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_USER_DATA created.;msgOffset=%hhu", msgOffset );
+OstTraceExt1( TRACE_NORMAL,  DUP7_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_USER_DATA created.;msgOffset=%hhu", msgOffset );
 }
 // Create SMS_SB_CHECK_INFO subblock if user data exists
 // Destination address length must be added to get user data
 // length index
 if ( aSmsCheckDisableFdn )
 {
-BuildSmsCheckInfo(
+msgOffset += BuildSmsCheckInfo(
 isiMsg,
 msgOffset );
 numOfSubblocks++;
 TFLOGSTRING("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_CHECK_INFO created." );
-OstTrace0( TRACE_NORMAL, DUP11_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_CHECK_INFO created." );
+OstTrace0( TRACE_NORMAL,  DUP11_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_SB_CHECK_INFO created." );
 }
 #if (NCP_COMMON_S60_VERSION_SUPPORT>S60_VERSION_32)
 iSMSSendingOngoing = ETrue;
 ISI_HEADER_SIZE + SMS_MESSAGE_SEND_REQ_OFFSET_SUBBLOCKCOUNT,
 numOfSubblocks );
 ret = iPhoNetSender->Send( isiMsg.Complete() );
 TFLOGSTRING3("TSY: CMmSmsMessHandler::CreateSmsMessageSendReq. SMS_MESSAGE_SEND_REQ was sent. Number of subblocks in message: %d, ret = %d", numOfSubblocks, ret  );
-OstTraceExt2( TRACE_NORMAL, DUP8_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_MESSAGE_SEND_REQ was sent.;numOfSubblocks=%hhu;ret=%d", numOfSubblocks, ret );
+OstTraceExt2( TRACE_NORMAL,  DUP8_CMMSMSMESSHANDLER_CREATESMSMESSAGESENDREQ_TD, "CMmSmsMessHandler::CreateSmsMessageSendReq.SMS_MESSAGE_SEND_REQ was sent.;numOfSubblocks=%hhu;ret=%d", numOfSubblocks, ret );
 } // End of if destination address is OK
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::SmsReceiveMessageReq( TUint8 aAction )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceiveMessageReq. Action = %d",aAction );
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEMESSAGEREQ, "CMmSmsMessHandler::SmsReceiveMessageReq;aAction=%hhu", aAction );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSRECEIVEMESSAGEREQ_TD, "CMmSmsMessHandler::SmsReceiveMessageReq;aAction=%hhu", aAction );
 TUint8 trId( 0 );
 if ( SMS_RECEPTION_STORAGE_STATUS_UPDATE == aAction )
 {
 trId = ESmsMessagingResumeSmsReception;
 //  |- SMS_SB_USER_DATA (optional, included if PDU contains user data.
 //                       Max. 8  + SMS_GSM_DELIVER_ACK_UD_MAX_LEN
 //                       + padding = 168 bytes)
 TFLOGSTRING3("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq - traId: %d, RP cause value: %d", aTransactionId, aRpCause);
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq;aTransactionId=%hhu;aRpCause=%d", aTransactionId, aRpCause );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq;aTransactionId=%hhu;aRpCause=%d", aTransactionId, aRpCause );
 TInt ret( KErrNone );
 TUint8 numOfSubblocks( 0 ); // All subblocks are optional
 TUint8 tpFailureCause( 0 );
 TUint8 causeType( 0 ); // SMS_CAUSE_TYPE_COMMON
 // If message data is available
 if ( NULL != aMsgData && 0 < aMsgData->Length() )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq. Message data availabe, length %d", aMsgData->Length());
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq;aMsgData->Length()=%d", aMsgData->Length() );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq;aMsgData->Length()=%d", aMsgData->Length() );
 TUint8 ind( 0 );
 // Message parameters = 1st byte of deliver report
 messageParameters = ( *aMsgData )[ind++];
 // Too many TP-PI octets -> this PDU is corrupted.
 if ( SMS_PARAM_INDICATOR_MAX_LEN < paramIndCount )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq. Error! Too mamy TP-PI parameters: %d", paramIndCount );
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq. Error!;paramIndCount=%hhu", paramIndCount );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq. Error!;paramIndCount=%hhu", paramIndCount );
 ret = KErrArgument;
 moreParamInd = EFalse;
 }
 }
 if ( KSmsParametersIndUserData & paramask )
 {
 tpUdl = ( *aMsgData )[ind++];
 }
 TFLOGSTRING4("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq. protocolInd: %d, dcs: %d, tpUdl: %d", protocolInd, dcs, tpUdl );
-OstTraceExt3( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq;protocolInd=%hhu;dcs=%hhu;tpUdl=%hhu", protocolInd, dcs, tpUdl );
+OstTraceExt3( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq;protocolInd=%hhu;dcs=%hhu;tpUdl=%hhu", protocolInd, dcs, tpUdl );
 // If user data exists, fill SMS_SB_USER_DATA and
 // SMS_SB_PARAM_INDICATOR subblocks
 if ( 0 < tpUdl )
 {
 } // end of if ( 0 == tpMti )
 else
 // TP-MTI is other than SMS_GSM_DELIVER_REPORT, message is not sent
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq. Error! Invalid message type indicator: %d", tpMti);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq;tpMti=%hhu", tpMti );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq;tpMti=%hhu", tpMti );
 ret = KErrArgument;
 }
 } // end of if ( NULL != aMsgData && 0 < aMsgData->Length() )
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsReceivedMsgReportReq. No message data availabe!");
-OstTrace0( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ, "CMmSmsMessHandler::SmsReceivedMsgReportReq. No message data available" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTREQ_TD, "CMmSmsMessHandler::SmsReceivedMsgReportReq. No message data available" );
 // If memory capacity exceeded -> gsmTpfailureCause is 0
 if ( 0 != aRpCause && SMS_EXT_ERR_MEMORY_CAPACITY_EXC != smsCause  )
 {
 // 0xAF is unspecified TP-command error
 tpFailureCause = 0xAF;
 // Maps RP cause value to SMS cause value.
 // --------------------------------------------------------------------------
 TUint8 CMmSmsMessHandler::SmsMapCause ( TInt aRpCause )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedPpReportReq - aRpCause: %d", aRpCause);
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSMAPCAUSE, "CMmSmsMessHandler::SmsMapCause;aRpCause=%d", aRpCause );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSMAPCAUSE_TD, "CMmSmsMessHandler::SmsMapCause;aRpCause=%d", aRpCause );
 //initialization of the Sms Cause value is 0x00 (SMS_CAUSE_OK)
 TUint8 retSmsCause( 0 );
 switch ( aRpCause )
 }
 default:
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedPpReportReq - unknown RpCause: %d", aRpCause);
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSMAPCAUSE, "CMmSmsMessHandler::SmsMapCause;unknown aRpCause=%d", aRpCause );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSMAPCAUSE_TD, "CMmSmsMessHandler::SmsMapCause;unknown aRpCause=%d", aRpCause );
 retSmsCause = SMS_EXT_ERR_PROTOCOL_ERROR;
 break;
 }
 }
 void CMmSmsMessHandler::SmsMessageSendResp(
 const TIsiReceiveC& aIsiMsg,
 TInt aIpc )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendResp - IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSMESSAGESENDRESP, "CMmSmsMessHandler::SmsMessageSendResp;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSMESSAGESENDRESP_TD, "CMmSmsMessHandler::SmsMessageSendResp;aIpc=%d", aIpc );
 TInt epocCause( KErrNone );
 TUint16 msgRef( 0 );
 TUint8 tpFailureCause( 0 );
 if ( SMS_ERR_RC_REJECTED  == smsServerCauseValue )
 {
 if ( EMobileSmsMessagingSendMessage == aIpc )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsMessageSendResp - server cause: SMS_ERR_RC_REJECTED");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP, "CMmSmsMessHandler::SmsMessageSendResp, server cause: SMS_ERR_RC_REJECTED" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP_TD, "CMmSmsMessHandler::SmsMessageSendResp, server cause: SMS_ERR_RC_REJECTED" );
 // This is an ETel MM-initiated SMS, barred by SAT.
 epocCause = CMmStaticUtility::EpocErrorCode(
 KErrAccessDenied,
 KErrSatControl );
 }
 else if (  EMmTsySmsSendSatMessage == aIpc )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsMessageSendResp - server cause: SMS_ERR_RC_REJECTED");
-OstTrace0( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP, "CMmSmsMessHandler::SmsMessageSendResp, server cause: SMS_ERR_RC_REJECTED" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP_TD, "CMmSmsMessHandler::SmsMessageSendResp, server cause: SMS_ERR_RC_REJECTED" );
 // This is a SAT-initiated SMS, barred by SAT.
 epocCause = KErrSatMoSmControlBarred;
 }
 }
 else
 smsServerCauseValue );
 }
 else // Invalid cause type
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsMessageSendResp: Unknown cause type %d.", smsServerCauseType );
-OstTraceExt1( TRACE_NORMAL, DUP5_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP, "CMmSmsMessHandler::SmsMessageSendResp;smsServerCauseType=%hhu", smsServerCauseType );
+OstTraceExt1( TRACE_NORMAL,  DUP5_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP_TD, "CMmSmsMessHandler::SmsMessageSendResp;smsServerCauseType=%hhu", smsServerCauseType );
 TF_ASSERT_NOT_REACHED();
 }
 }
 else // Sending was OK
 {
 //complete the request
 #if (NCP_COMMON_S60_VERSION_SUPPORT==S60_VERSION_32)
 iMessageRouter->Complete( EMmTsySmsSendSatMessage, epocCause );
 #else
 #ifdef __WINSCW__
 // for simatktsy testtool
-// Temporarily removed for Bridge camp!
+if ( iMessageRouter->iSatMessaging )
-/*if ( iMessageRouter->iSatMessaging )
+{
-{
+iMessageRouter->iSatMessaging->CompleteSendSmsMessage ( epocCause );
-iMessageRouter->iSatMessaging->CompleteSendSmsMessage ( epocCause );
+}
-}
 // for nokiatsy testtool
-*/
+iMessageRouter->Complete ( EMmTsySmsSendSatMessage, epocCause );
-iMessageRouter->Complete ( EMmTsySmsSendSatMessage, epocCause );
 #else // __WINSCW__
-// Temporarily removed for Bridge camp!
+iMessageRouter->iSatMessaging->CompleteSendSmsMessage ( epocCause );
-//iMessageRouter->iSatMessaging->CompleteSendSmsMessage ( epocCause );
 #endif // __WINSCW__
 iSMSSendingOngoing = EFalse;
 #endif //NCP_COMMON_S60_VERSION_SUPPORT
 }
 else
 {
 TFLOGSTRING2("TSY:CMmSmsMessHandler::SmsMessageSendResp:Unexpected IPC %d.",aIpc);
-OstTrace1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP, "CMmSmsMessHandler::SmsMessageSendResp;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  DUP6_CMMSMSMESSHANDLER_SMSMESSAGESENDRESP_TD, "CMmSmsMessHandler::SmsMessageSendResp;aIpc=%d", aIpc );
 }
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::SmsReceiveMessageResp
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::SmsReceiveMessageResp( const TIsiReceiveC& aIsiMsg )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsReceiveMessageResp");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSPPROUTINGRESP, "CMmSmsMessHandler::SmsReceiveMessageResp" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSPPROUTINGRESP_TD, "CMmSmsMessHandler::SmsReceiveMessageResp" );
 // Get transaction ID for completing with correct IPC
 TUint8 trId( aIsiMsg.Get8bit(
 ISI_HEADER_SIZE + SMS_RECEIVE_MESSAGE_RESP_OFFSET_TRANSID ) );
 // Get reception status
 TInt epocError( CMmStaticUtility::CSCauseToEpocError(
 PN_SMS,
 smsServerCauseType,
 smsServerCauseValue ) );
-if ( KErrNone == epocError )
-{
-// even if client deactivates reception, next time it is activated
-// SMS server will ask network to resend all NACKed MT SMs
-// only query status does not affect this flag, but this action
-// is not used
-iMemoryCapacityExceeded = EFalse;
-}
 // Compete active reception status
 if ( SMS_RECEPTION_ACTIVE == receptionStatus )
 {
 if ( 0 == trId ) // SMS receiving activated
 {
 TBool CMmSmsMessHandler::IsSmsClass2(
 const TIsiReceiveC& aIsiMsg, //Isi Msg
 TUint8& aSmsClass2ReplaceTpPid ) // TP-PID to replace (set by this function)
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::IsSmsClass2");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_ISSMSCLASS2, "CMmSmsMessHandler::IsSmsClass2" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_ISSMSCLASS2_TD, "CMmSmsMessHandler::IsSmsClass2" );
 TBool smsClass2( EFalse );
 TBool cphsCase( EFalse );
 // If received Class 2 SMS is a "replace type" message, contains
 // the TP-PID value, else value is zero.
 // This is a CPHS message indicator. No further
 // check of DCS and PID necessary.
 cphsCase = ETrue;
 smsClass2 = EFalse;
 TFLOGSTRING("TSY: CMmSmsMessHandler::IsSmsClass2: CPHS message");
-OstTrace0( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_ISSMSCLASS2, "CMmSmsMessHandler::IsSmsClass2. CPHS message" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_ISSMSCLASS2_TD, "CMmSmsMessHandler::IsSmsClass2. CPHS message" );
 }
 }
 }
 }
 // End CPHS special case handling
 // chapter 9.2.3.9 "TP Protocol Identifier (TP PID)"
 if ( ( 0x41 <= protocolId ) && ( 0x47 >= protocolId ) )
 {
 // Yes, this is a "replace type" message
 TFLOGSTRING2("TSY: CMmSmsMessHandler::IsSmsClass2: Replace type message, protocol ID: %d", protocolId );
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_ISSMSCLASS2, "CMmSmsMessHandler::IsSmsClass2. Replace type message;protocolId=%hhu", protocolId );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_ISSMSCLASS2_TD, "CMmSmsMessHandler::IsSmsClass2. Replace type message;protocolId=%hhu", protocolId );
 aSmsClass2ReplaceTpPid = protocolId;
 }
 // TP-DCS tells us the class of the SMS
 TUint8 dataCodingScheme( sms[index++] );
 if ( 0 != aSmsClass2ReplaceTpPid )
 {
 if ( smsClass2 )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsClass: Received class 2 message has TP-PID 0x%x", aSmsClass2ReplaceTpPid);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_ISSMSCLASS2, "CMmSmsMessHandler::IsSmsClass2;aSmsClass2ReplaceTpPid=%hhx", aSmsClass2ReplaceTpPid );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_ISSMSCLASS2_TD, "CMmSmsMessHandler::IsSmsClass2;aSmsClass2ReplaceTpPid=%hhx", aSmsClass2ReplaceTpPid );
 }
 else
 {
 aSmsClass2ReplaceTpPid = 0;
 }
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::SmsReceivedMsgInd( const TIsiReceiveC& aIsiMsg )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsReceivedMsgInd");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSPPROUTINGNTF, "CMmSmsMessHandler::SmsReceivedMsgInd" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSPPROUTINGNTF_TD, "CMmSmsMessHandler::SmsReceivedMsgInd" );
-if ( iMemoryCapacityExceeded )
+TInt ret( KErrNone );
-{
+// Create a package
-TFLOGSTRING("TSY: CMmSmsMessHandler::SmsReceivedMsgInd no storage - internal NACK");
+CMmDataPackage package;
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEDMSGIND, "CMmSmsMessHandler::SmsReceivedMsgInd no storage - internal NACK" );
-// error is ignored
+TUint8 replaceTpPid( 0 ); // IsSmsClass2 also fills this
-SmsReceivedMsgReportReq(
+TBool receivedSmsClass2( IsSmsClass2( aIsiMsg, replaceTpPid ) );
-EInternalNack,
-NULL,
+// SIM SMS cache: incoming class 2 SMS
-KErrGsmSMSMemoryCapacityExceeded );
+if ( receivedSmsClass2 )
-}
+{
+ret = SmsClass2ReceivedMsgInd( aIsiMsg, replaceTpPid );
+}
+// Received SMS is not a class 2 SMS (it is a normal SMS)
 else
 {
-TInt ret( KErrNone );
+ret = SmsClass1ReceivedMsgInd( aIsiMsg );
-// Create a package
+}
-CMmDataPackage package;
+// There was an error, complete to upper level
+if ( KErrNone != ret )
-TUint8 replaceTpPid( 0 ); // IsSmsClass2 also fills this
+{
-TBool receivedSmsClass2( IsSmsClass2( aIsiMsg, replaceTpPid ) );
-// SIM SMS cache: incoming class 2 SMS
-if ( receivedSmsClass2 )
-{
-ret = SmsClass2ReceivedMsgInd( aIsiMsg, replaceTpPid );
-}
-// Received SMS is not a class 2 SMS (it is a normal SMS)
-else
-{
-ret = SmsClass1ReceivedMsgInd( aIsiMsg );
-}
-// There was an error, complete to upper level
-if ( KErrNone != ret )
-{
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsReceivedMsgInd;ret=%d", ret);
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSPPROUTINGNTF, "CMmSmsMessHandler::SmsReceivedMsgInd;ret=%d", ret );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSPPROUTINGNTF_TD, "CMmSmsMessHandler::SmsReceivedMsgInd;ret=%d", ret );
 TBool smsInd( ETrue );
 TSmsMsg* nullSms = NULL;
 package.PackData( &smsInd, &nullSms );
 // Complete request to client
 iMessageRouter->Complete(
 EMobileSmsMessagingReceiveMessage,
 &package,
 ret );
-}
 }
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::SmsReceivedMsgReportResp
 + SMS_RECEIVED_MSG_REPORT_RESP_OFFSET_TRANSID ) );
 TUint8 cause( aIsiMsg.Get8bit( ISI_HEADER_SIZE
 + SMS_RECEIVED_MSG_REPORT_RESP_OFFSET_SMSCAUSE ) );
 TFLOGSTRING3("TSY: CMmSmsMessHandler::SmsReceivedPpReportResp - traId: %d, cause: %d", traId, cause);
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTRESP, "CMmSmsMessHandler::SmsReceivedPpReportResp;traId=%hhu;cause=%hhu", traId, cause );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTRESP_TD, "CMmSmsMessHandler::SmsReceivedPpReportResp;traId=%hhu;cause=%hhu", traId, cause );
-if ( iMemoryCapacityExceeded )
+// Response for SmsReceivedPpReportReq (Ack)
-{
+if ( ESmsMessagingAckSmsStored == traId )
-// ignore the response, this is response to self-NACK
+{
-// caused by client not having anymore storage space
+iMessageRouter->Complete(
-TFLOGSTRING("TSY: CMmSmsMessHandler::SmsReceivedPpReportResp - self-NACK");
+EMobileSmsMessagingAckSmsStored,
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRECEIVEDMSGREPORTRESP, "CMmSmsMessHandler::SmsReceivedPpReportResp - self-NACK" );
+CMmStaticUtility::CSCauseToEpocError(
+PN_SMS,
+SMS_CAUSE_TYPE_COMMON,
+cause ) );
+}
+// Response for SmsReceivedPpReportReq (Nack)
+else if ( ESmsMessagingNackSmsStored == traId )
+{
+iMessageRouter->Complete(
+EMobileSmsMessagingNackSmsStored,
+CMmStaticUtility::CSCauseToEpocError(
+PN_SMS,
+SMS_CAUSE_TYPE_COMMON,
+cause ) );
 }
 else
 {
-// Response for SmsReceivedPpReportReq (Ack)
-if ( ESmsMessagingAckSmsStored == traId )
-{
-iMessageRouter->Complete(
-EMobileSmsMessagingAckSmsStored,
-CMmStaticUtility::CSCauseToEpocError(
-PN_SMS,
-SMS_CAUSE_TYPE_COMMON,
-cause ) );
-}
-// Response for SmsReceivedPpReportReq (Nack)
-else if ( ESmsMessagingNackSmsStored == traId ||
-ESmsMessagingNackSmsStoredCapacityExceeded == traId )
-{
-iMessageRouter->Complete(
-EMobileSmsMessagingNackSmsStored,
-CMmStaticUtility::CSCauseToEpocError(
-PN_SMS,
-SMS_CAUSE_TYPE_COMMON,
-cause ) );
-}
-else
-{
 TFLOGSTRING2("TSY:CMmSmsMessHandler::SmsReceivedPpReportResp:Unexpected transaction ID %d.",traId);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTRESP, "CMmSmsMessHandler::SmsReceivedPpReportResp;Unexpected  transaction ID=%hhu", traId );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSRECEIVEDPPREPORTRESP_TD, "CMmSmsMessHandler::SmsReceivedPpReportResp;Unexpected  transaction ID=%hhu", traId );
 }
 if ( SMS_OK != cause )
 {
 //Acknowledging failed.
-iMemoryCapacityExceeded = EFalse;
+iSmsSlotLocation = 0;
-iSmsSlotLocation = 0;
-}
-else if ( ESmsMessagingNackSmsStoredCapacityExceeded == traId )
-{
-// client succeeded NACKing MT SM
-// it wont receive any further MT SM indications
-iMemoryCapacityExceeded = ETrue;
-}
 }
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::BuildScAddress
 void CMmSmsMessHandler::BuildScAddress(
 RMobilePhone::TMobileAddress const & scPtr, //Pointer to Service center
 TDes8 &aScAddress ) const                  //Service center address
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::BuildScAddress");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSCADDRESS, "CMmSmsMessHandler::BuildScAddress" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSCADDRESS_TD, "CMmSmsMessHandler::BuildScAddress" );
 //get type of number from attributes
 RMobilePhone::TMobileTON ton( scPtr.iTypeOfNumber );
 //map type of number from TMobileTON to TUint8
 TUint8 typeOfNumber( CMmSmsGsmAddress::GsmMapTonToTUint8( ton ) );
 //get numbering plan identification from attributes
 void CMmSmsMessHandler::BuildDeAddress(
 RMobilePhone::TMobileAddress const & scPtr,  // Service centre pointer
 TDes8 &aDeAddress ) const                    // Destination address
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::BuildDeAddress");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDDEADDRESS, "CMmSmsMessHandler::BuildDeAddress" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDDEADDRESS_TD, "CMmSmsMessHandler::BuildDeAddress" );
 //get type of number from attributes
 RMobilePhone::TMobileTON ton( scPtr.iTypeOfNumber );
 //map type of number from TMobileTON to TUint8
 TUint8 typeOfNumber( CMmSmsGsmAddress::GsmMapTonToTUint8( ton ) );
 // -----------------------------------------------------------------------------
 //
 TBool CMmSmsMessHandler::IsDataCodingScheme7Bit( TUint8 aDcs ) const
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::IsDataCodingScheme7Bit");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_ISDATACODINGSCHEME7BIT, "CMmSmsMessHandler::IsDataCodingScheme7Bit" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_ISDATACODINGSCHEME7BIT_TD, "CMmSmsMessHandler::IsDataCodingScheme7Bit" );
 TUint8 codingGroup( static_cast<TUint8>( 0xf0 & aDcs ) );  // 11110000
 TUint8 lowerBits( static_cast<TUint8>( 0x0f & aDcs ) );    // 00001111
 // See 3GPP TS 23.038 "Technical Specification Group Terminals;
 //Alphabets and language-specific information"
 TUint8 aCharacterAmount,           //Character amount (from ISI message)
 TUint8 aDataLength,                //Data length in bytes (from ISI message)
 TPtrC8 const & aUserData ) const   //User data
 {
 TFLOGSTRING3("TSY: CMmSmsMessHandler::CalculateNumberOfCharsInUserData - char amount (from ISI): %d, data length (from ISI): %d", aCharacterAmount, aDataLength);
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_CALCULATENUMBEROFCHARSINUSERDATA, "CMmSmsMessHandler::CalculateNumberOfCharsInUserData;aCharacterAmount=%hhu;aDataLength=%hhu", aCharacterAmount, aDataLength );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_CALCULATENUMBEROFCHARSINUSERDATA_TD, "CMmSmsMessHandler::CalculateNumberOfCharsInUserData;aCharacterAmount=%hhu;aDataLength=%hhu", aCharacterAmount, aDataLength );
 TUint16 characterAmount;
 // This calculation is only needed if the number of characters is
 // not provided in the aCharacterAmount parameter. Seems to be some
 TInt CMmSmsMessHandler::ExtFuncL(
 TInt aIpc,                           // IPC number
 const CMmDataPackage* aDataPackage ) // Data package
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::ExtFuncL: IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL;aIpc=%d", aIpc );
 TInt ret( KErrNone );
 switch ( aIpc )
 {
 }
 case EMmTsyActivateSmsRouting:
 {
 #if defined( INTERNAL_TESTING_SMS_WITH_EMULATOR )  && ( ! defined( __WINS__ ) )
 TFLOGSTRING("TSY: CMmSmsMessHandler::ExtFuncL: SMS routing deactivated with flag INTERNAL_TESTING_SMS_WITH_EMULATOR");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL, SMS routing deactivated with flag INTERNAL_TESTING_SMS_WITH_EMULATOR" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL, SMS routing deactivated with flag INTERNAL_TESTING_SMS_WITH_EMULATOR" );
 #else
 ret = SmsReceiveMessageReq( SMS_RECEPTION_ACTIVATE );
 #endif // defined( INTERNAL_TESTING_SMS_WITH_EMULATOR ) && ( ! defined( __WINS__ ) )
 break;
 }
 reinterpret_cast<TBuf8<RMobileSmsMessaging::KGsmTpduSize> *> ( data );
 if ( NULL == msgData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ExtFuncL.Internal Ack handling started" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL, Internal Ack handling started" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL, Internal Ack handling started" );
 }
 ret = SmsReceivedMsgReportReq(
 ESmsMessagingAckSmsStored,
 msgData,
 KErrNone );
 aDataPackage->UnPackData( msgData, rpCause );
 if ( NULL == msgData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ExtFuncL.Internal Nack handling started" );
-OstTrace0( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL, Internal Nack handling started" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL, Internal Nack handling started" );
 }
-// NACK due to lack of storage space causes NTSY to reject further
-// MT SMs until client resumes SMS reception
-TUint8 traId = KErrGsmSMSMemoryCapacityExceeded == rpCause ?
-ESmsMessagingNackSmsStoredCapacityExceeded : ESmsMessagingNackSmsStored;
 ret = SmsReceivedMsgReportReq(
-traId,
+ESmsMessagingNackSmsStored,
 msgData,
 rpCause );
 break;
 }
 case EMobilePhoneStoreDelete:
 break;
 }
 case ECustomSetSimMessageStatusReadIPC:
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ExtFuncL - ECustomSetSimMessageStatusReadIPC starts.");
-OstTrace0( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL, ECustomSetSimMessageStatusReadIPC starts" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL, ECustomSetSimMessageStatusReadIPC starts" );
 TTime scTime;
 TInt timezoneDiff;
 aDataPackage->UnPackData( scTime, timezoneDiff );
 // start searching for a SIM message with this timestamp
 }
 }
 currentSlot++;
 }
 TFLOGSTRING("TSY: CMmSmsMessHandler::ExtFuncL - ECustomSetSimMessageStatusReadIPC done.");
-OstTrace0( TRACE_NORMAL, DUP5_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL, ECustomSetSimMessageStatusReadIPC done" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL, ECustomSetSimMessageStatusReadIPC done" );
 ret = KErrNone;
 break;
 }
 case EMobileSmsMessagingSetMoSmsBearer:
 {
 break;
 }
 default:
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_EXTFUNCL, "CMmSmsMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  DUP6_CMMSMSMESSHANDLER_EXTFUNCL_TD, "CMmSmsMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc );
 ret = KErrArgument;
 break;
 }
 }
 return ret;
 TUint8 aReceivedTpPid,                             //received TP-PID
 const TIsiReceiveC&  aReceivedSmsIsiMsg,           //received isi msg
 RMobileSmsStore::TMobileGsmSmsEntryV1* aSMSOnSIM ) //SMS stored on SIM
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter, aReceivedTpPid = %d", aReceivedTpPid);
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter;aReceivedTpPid=%hhu", aReceivedTpPid );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER_TD, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter;aReceivedTpPid=%hhu", aReceivedTpPid );
 TBool matchFound( EFalse );
 // Get protocol id from stored SMS
 }
 }
 else // could not extract data from received message
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter: Could not extract data from received message");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter: Could not extract data from received message" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER_TD, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter: Could not extract data from received message" );
 return EFalse;
 }
 // 2. Get sender address from received message
 TUint smsUserDataOffset( 0 );
 }
 }
 else // Could not extract data from received message
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter: Could not extract data from received message");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter - Could not extract data from received message" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_CHECKTPPIDANDSENDERANDSERVICECENTER_TD, "CMmSmsMessHandler::CheckTpPidAndSenderAndServiceCenter - Could not extract data from received message" );
 return EFalse;
 }
 // 3. Get sender number from stored message
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::GetSmsStoreInfo( TInt aIpc )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::GetSmsStoreInfo - IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_GETSMSSTOREINFO, "CMmSmsMessHandler::GetSmsStoreInfo;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_GETSMSSTOREINFO_TD, "CMmSmsMessHandler::GetSmsStoreInfo;aIpc=%d", aIpc );
 TInt ret( KErrNone );
 // SIM SMS cache:
 // -- EMobileSmsMessagingGetMessageStoreInfo/EMobilePhoneStoreGetInfo
 if ( KErrNone == iSmsCache.Status() )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetSmsStoreInfo -- completed immediatedly");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_GETSMSSTOREINFO, "CMmSmsMessHandler::GetSmsStoreInfo, completed immediatedly" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_GETSMSSTOREINFO_TD, "CMmSmsMessHandler::GetSmsStoreInfo, completed immediatedly" );
 TUint8 numOfLoc( TUint8( iSmsCache.TotalEntries() ) );
 TInt usedEntries( iSmsCache.UsedEntries() );
 CMmDataPackage data;
 data.PackData( &numOfLoc, &usedEntries );
 iMessageRouter->Complete( aIpc, &data, KErrNone );
 }
 // try to recover from out of memory condition
 else if ( KErrNoMemory == iSmsCache.Status() )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetSmsStoreInfo -- recovering from OOM");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_GETSMSSTOREINFO, "CMmSmsMessHandler::GetSmsStoreInfo, recovering from OOM" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_GETSMSSTOREINFO_TD, "CMmSmsMessHandler::GetSmsStoreInfo, recovering from OOM" );
 InitializeSmsCache();
 }
 // cache is not ready, start waiting
 else if ( KErrNotReady == iSmsCache.Status() )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetSmsStoreInfo -- waiting");
-OstTrace0( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_GETSMSSTOREINFO, "CMmSmsMessHandler::GetSmsStoreInfo, waiting" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_GETSMSSTOREINFO_TD, "CMmSmsMessHandler::GetSmsStoreInfo, waiting" );
 }
 // some other, error return error value
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetSmsStoreInfo -- failed");
-OstTrace0( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_GETSMSSTOREINFO, "CMmSmsMessHandler::GetSmsStoreInfo, failed" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_GETSMSSTOREINFO_TD, "CMmSmsMessHandler::GetSmsStoreInfo, failed" );
 ret = iSmsCache.Status();
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::DeleteSms( const CMmDataPackage* aDataPackage )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::DeleteSms");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_DELETESMS, "CMmSmsMessHandler::DeleteSms" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_DELETESMS_TD, "CMmSmsMessHandler::DeleteSms" );
 // SIM SMS cache: -- EMobilePhoneStoreDelete
 TInt ret( KErrNone );
 // Symbian sms stack will try to delete received SMS2 from SIM if it can't
 // save it to filesystem, so deletion should be possible in out of memory
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::DeleteSms, cache not ready/failed");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_DELETESMS, "CMmSmsMessHandler::DeleteSms, cache not ready/failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_DELETESMS_TD, "CMmSmsMessHandler::DeleteSms, cache not ready/failed" );
 ret = iSmsCache.Status();
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::DeleteAllSms()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::DeleteAllSms");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_DELETEALLSMS, "CMmSmsMessHandler::DeleteAllSms" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_DELETEALLSMS_TD, "CMmSmsMessHandler::DeleteAllSms" );
 TInt ret( KErrNone );
 // SIM SMS cache: -- EMobilePhoneStoreDeleteAll
 if ( KErrNone == iSmsCache.Status() )
 {
 if ( 0 < iSmsCache.TotalEntries() )
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::DeleteAllSms, cache not ready/failed");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_DELETEALLSMS, "CMmSmsMessHandler::DeleteAllSms, cache not ready/failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_DELETEALLSMS_TD, "CMmSmsMessHandler::DeleteAllSms, cache not ready/failed" );
 ret = iSmsCache.Status();
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::ReadSms( const CMmDataPackage* aDataPackage )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ReadSms");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_READSMS, "CMmSmsMessHandler::ReadSms" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_READSMS_TD, "CMmSmsMessHandler::ReadSms" );
 TInt ret( KErrNone );
 TInt location( 0 );
 //unpack data
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ReadSms, cache not ready/failed");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_READSMS, "CMmSmsMessHandler::ReadSms, cache not ready/failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_READSMS_TD, "CMmSmsMessHandler::ReadSms, cache not ready/failed" );
 ret = iSmsCache.Status();
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::ReadAllSmsL()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ReadAllSms");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_READALLSMSL, "CMmSmsMessHandler::ReadAllSmsL" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_READALLSMSL_TD, "CMmSmsMessHandler::ReadAllSmsL" );
 TInt ret( KErrNone );
 // SIM SMS cache: -- EMobilePhoneStoreReadAllPhase1
 if ( KErrNone == iSmsCache.Status() )
 {
 iReceivedClass2ToBeReSent = EFalse;
 }
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::ReadAllSms --- cache not ready/failed");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_READALLSMSL, "CMmSmsMessHandler::ReadAllSmsL, cache not ready/failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_READALLSMSL_TD, "CMmSmsMessHandler::ReadAllSmsL, cache not ready/failed" );
 iSmsListArray->ResetAndDestroy();
 CMmDataPackage package;
 package.PackData( &iSmsListArray, &iReceivedClass2ToBeReSent );
 iMessageRouter->Complete(
 EMobilePhoneStoreReadAllPhase1,
 TInt aIndex)
 {
 TInt ret( KErrNone );
 TFLOGSTRING("TSY: CMmSmsMessHandler::WriteSms");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_WRITESMS, "CMmSmsMessHandler::WriteSms" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_WRITESMS_TD, "CMmSmsMessHandler::WriteSms" );
 // SIM SMS cache: -- EMobilePhoneStoreWrite
 //check if sms writing is ongoing or not
 if ( 0 != iSmsSlotLocation )
 {
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::InitializeSmsCache()
 {
 // SIM SMS cache: initialize cache
+if( KErrNotReady != iSmsCache.Status() )
+{
 TFLOGSTRING("TSY: CMmSmsMessHandler::InitializeSmsCache -- SMS CACHEING START ---");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_INITIALIZESMSCACHE, "CMmSmsMessHandler::InitializeSmsCache" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_INITIALIZESMSCACHE_TD, "CMmSmsMessHandler::InitializeSmsCache" );
 iSmsCache.Reset();
 GetNumOfEFSMSRecords (); // Read EF SMS count.
+}
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::HandleError
 // Handles CMmSmsMessHandler's errors comes via PhoNetReceiver RunError method.
 const TIsiReceiveC& aIsiMsg, // Isi message
 TInt aError )                // Error code
 {
 TFLOGSTRING2( "TSY: CMmSmsMessHandler::HandleError - Error: %d", aError );
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_HANDLEERROR, "CMmSmsMessHandler::HandleError;aError=%d", aError );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_HANDLEERROR_TD, "CMmSmsMessHandler::HandleError;aError=%d", aError );
 TUint8 resource( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 TUint8 messageId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 TUint8 transId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
 TFLOGSTRING4( "TSY: CMmSmsMessHandler::HandleError - resource: %d, msgId: %d, traId: %d", resource, messageId, transId );
-OstTraceExt3(TRACE_NORMAL,DUP1_CMMSMSMESSHANDLER_HANDLEERROR,"CMmSmsMessHandler::HandleError;resource=%hhu;messageId=%hhu;transId=%hhu", resource, messageId, transId );
+OstTraceExt3(TRACE_NORMAL,DUP1_CMMSMSMESSHANDLER_HANDLEERROR_TD,"CMmSmsMessHandler::HandleError;resource=%hhu;messageId=%hhu;transId=%hhu", resource, messageId, transId );
 switch ( resource )
 {
 default:
 {
 TFLOGSTRING2( "TSY: CMmSmsMessHandler::HandleError - PN_SMS, unknown resource: %d", resource );
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_HANDLEERROR, "CMmSmsMessHandler::HandleError;resource=%hhu", resource );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_HANDLEERROR_TD, "CMmSmsMessHandler::HandleError;resource=%hhu", resource );
 // Nothing to do here.
 break;
 }
 }
 }
 //
 TInt CMmSmsMessHandler::SmsSettingsUpdateReq(
 RMobileSmsMessaging::TMobileSmsBearer& aBearer )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsSettingsUpdateReq. aBearer: %d", aBearer);
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ, "CMmSmsMessHandler::SmsSettingsUpdateReq;aBearer=%d", aBearer );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ_TD, "CMmSmsMessHandler::SmsSettingsUpdateReq;aBearer=%d", aBearer );
 TUint8 csRoutePriority( SMS_ROUTE_NOT_AVAILABLE );
 TUint8 psRoutePriority( SMS_ROUTE_NOT_AVAILABLE );
 // The bearer information must be used in two ways:
 break;
 }
 default:
 {
 TFLOGSTRING2("TSY:CMmSmsMessHandler::SmsSettingsUpdateReq:Invalid bearer = %d",iMobileSmsBearer);
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ, "CMmSmsMessHandler::SmsSettingsUpdateReq;iMobileSmsBearer=%d", iMobileSmsBearer );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ_TD, "CMmSmsMessHandler::SmsSettingsUpdateReq;iMobileSmsBearer=%d", iMobileSmsBearer );
 break;
 }
 }
 TFLOGSTRING3("TSY:CMmSmsMessHandler::SmsSettingsUpdateReq:CS priority = %d, PS priority = %d",csRoutePriority,psRoutePriority);
-OstTraceExt2( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ, "CMmSmsMessHandler::SmsSettingsUpdateReq;csRoutePriority=%hhd;psRoutePriority=%hhd", csRoutePriority, psRoutePriority );
+OstTraceExt2( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSSETTINGSUPDATEREQ_TD, "CMmSmsMessHandler::SmsSettingsUpdateReq;csRoutePriority=%hhd;psRoutePriority=%hhd", csRoutePriority, psRoutePriority );
 // SMS_SB_ROUTE_INFO sub block (8 bytes)
 TBuf8<SIZE_SMS_SB_ROUTE_INFO> smsRouteInfoBuf( 0 );
 TIsiSubBlock smsRouteInfoSb(
 smsRouteInfoBuf,
 {
 TUint8 cause( aIsiMsg.Get8bit(
 ISI_HEADER_SIZE + SMS_SETTINGS_UPDATE_RESP_OFFSET_SMSCAUSE ) );
 TFLOGSTRING2("TSY:CMmSmsMessHandler::SmsSettingsUpdateResp: response status=%d.",cause);
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSGSMSETTINGSUPDATERESP, "CMmSmsMessHandler::SmsSettingsUpdateResp;cause=%hhu", cause );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSGSMSETTINGSUPDATERESP_TD, "CMmSmsMessHandler::SmsSettingsUpdateResp;cause=%hhu", cause );
 TInt err( CMmStaticUtility::CSCauseToEpocError(
 PN_SMS,
 SMS_CAUSE_TYPE_COMMON,
 cause ) );
 TInt CMmSmsMessHandler::SmsClass2ReceivedMsgInd(
 const TIsiReceiveC& aIsiMsg,
 TUint8 aIsReplace )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsClass2ReceivedMsgInd");
-OstTrace0( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd" );
 TInt ret( KErrNone );
 TUint smsTpduOffset( 0 );
 if ( KErrNone == aIsiMsg.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_SMS_RECEIVED_MSG_IND,
 // If this is a replace message, try find a SMS to replace
 if ( aIsReplace )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsClass2ReceivedMsgInd --- replace");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd, replace" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd, replace" );
 for ( TInt i( 0 ); i <= iSmsCache.TotalEntries(); i++ )
 {
 RMobileSmsStore::TMobileGsmSmsEntryV1* simIsiMsg =
 iSmsCache.GetEntry( i );
 if ( simIsiMsg )
 // Location found, start SMS writing
 if ( 0 != location )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsClass2ReceivedMsgInd -- incoming SMS2, writing to location %d", location);
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd;incoming SMS2, writing to location=%d", location );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd;incoming SMS2, writing to location=%d", location );
 // iSmsSlotLocation = TUint8(location);
 // Write received class2 SMS to SIM Card
 // Get data from incoming message.
 RMobileSmsStore::TMobileGsmSmsEntryV1 incomingSMS;
 // Cache not ready
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsClass2ReceivedMsgInd -- incoming SMS2, cache not ready/failed");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd, incoming SMS2, cache not ready/failed" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd, incoming SMS2, cache not ready/failed" );
 ret = KErrGsmSMSMemoryCapacityExceeded;
 // Setting this true will cause it to be resent?
 iReceivedClass2ToBeReSent = ETrue;
 // If this is out of memory error, try to refill cache..
 }
 }
 }
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SmsClass2ReceivedMsgInd ret=%d", ret);
-OstTrace1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd;ret=%d", ret );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_SMSCLASS2PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass2ReceivedMsgInd;ret=%d", ret );
 return ret;
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::SmsClass1ReceivedMsgInd
 //
 TInt CMmSmsMessHandler::SmsClass1ReceivedMsgInd(
 const TIsiReceiveC& aIsiMsg)
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::SmsClass1ReceivedMsgInd");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd" );
 TInt ret( KErrNone );
 TBool validPduFormat( EFalse );
 TSmsMsg  smsMsgValue;
 TSmsMsg* smsMsg = &smsMsgValue;
 smsMsg->iMobileScNPI );
 }
 else
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::SmsClass1ReceivedMsgInd,SMS_SB_ADDRESS expected");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd,SMS_SB_ADDRESS expected" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd,SMS_SB_ADDRESS expected" );
 TF_ASSERT_NOT_REACHED();
 }
 // Handle SMS_SB_TPDU subblock
 TUint smsTpduOffset( 0 );
 }
 }
 else
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::SmsClass1ReceivedMsgInd, SMS_SB_USER_DATA expected");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd, SMS_SB_USER_DATA expected" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd, SMS_SB_USER_DATA expected" );
 TF_ASSERT_NOT_REACHED();
 }
 if ( validPduFormat )
 {
 // Caller is forced to complete
 ret = KErrGeneral;
 }
 }
 TFLOGSTRING2("TSY:CMmSmsMessHandler::SmsClass1ReceivedMsgInd;ret=%d", ret);
-OstTrace1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd;ret=%d", ret );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_SMSCLASS1PPROUTINGNTF_TD, "CMmSmsMessHandler::SmsClass1ReceivedMsgInd;ret=%d", ret );
 return ret;
 }
 // -----------------------------------------------------------------------------
 const TDesC8& aMsgData,
 TUint8 subBlockId,
 TUint8& aDestAddressLength ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::GetDestAddressLength");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH, "CMmSmsMessHandler::GetDestAddressLength" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH_TD, "CMmSmsMessHandler::GetDestAddressLength" );
 TInt ret( KErrNone );
 if ( SMS_SB_SUBMIT == subBlockId )
 {
 }
 else
 {
 ret = KErrArgument;
 TFLOGSTRING2("TSY:CMmSmsMessHandler::GetDestinationAddressLength: Error! Destination address too long: %d.",aDestAddressLength);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH, "CMmSmsMessHandler::GetDestAddressLength;aDestAddressLength=%hhu", aDestAddressLength );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH_TD, "CMmSmsMessHandler::GetDestAddressLength;aDestAddressLength=%hhu", aDestAddressLength );
 }
 TFLOGSTRING2("TSY:CMmSmsMessHandler::GetDestinationAddressLength:Destination address length %d.",aDestAddressLength);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH, "CMmSmsMessHandler::GetDestAddressLength;aDestAddressLength=%hhu", aDestAddressLength );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_GETDESTADDRESSLENGTH_TD, "CMmSmsMessHandler::GetDestAddressLength;aDestAddressLength=%hhu", aDestAddressLength );
 return ret;
 }
 // -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsSbSubmit
 // Creates SMS_SB_SUBMIT subblock and appends it to ISI message
 // -----------------------------------------------------------------------------
 //
-void CMmSmsMessHandler::BuildSmsSbSubmit(
+TUint16 CMmSmsMessHandler::BuildSmsSbSubmit(
 const TDesC8& aMsgData,
 TIsiSend& aIsiMsg,
-TUint8 aMsgOffset,
+TUint8 aDestAddressLength,
-TUint8 aDestAddressLength ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsSbSubmit");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSSBSUBMIT, "CMmSmsMessHandler::BuildSmsSbSubmit" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSSBSUBMIT_TD, "CMmSmsMessHandler::BuildSmsSbSubmit" );
 // Extract needed parameters from TPDU for for SMS_SB_SUBMIT
 TUint8 messageParameters( aMsgData[ KTpduIndexMessageParameters ] );
 TUint8 messageReference( aMsgData[ KTpduIndexMessageReference ] );
 TUint8 protocolId( aMsgData[ KTpduSubmitIndexProtocolIdentifier +
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbSubmit. Message parameters: %d", messageParameters );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbSubmit. Message reference: %d", messageReference );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbSubmit. Protocol ID: %d", protocolId );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbSubmit. Data coding scheme: %d", dataCodingScheme );
-OstTraceExt4( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_BUILDSMSSBSUBMIT, "CMmSmsMessHandler::BuildSmsSbSubmit;messageParameters=%hhu;messageReference=%hhu;protocolId=%hhu;dataCodingScheme=%hhu", messageParameters, messageReference, protocolId, dataCodingScheme );
+OstTraceExt4( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_BUILDSMSSBSUBMIT_TD, "CMmSmsMessHandler::BuildSmsSbSubmit;messageParameters=%hhu;messageReference=%hhu;protocolId=%hhu;dataCodingScheme=%hhu", messageParameters, messageReference, protocolId, dataCodingScheme );
-}
+return submitBuf.Length();
+}
-// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsSbCommand
 // Creates SMS_SB_COMMAND subblock and appends it to ISI message
 // -----------------------------------------------------------------------------
-void CMmSmsMessHandler::BuildSmsSbCommand(
+TUint16 CMmSmsMessHandler::BuildSmsSbCommand(
 const TDesC8& aMsgData,
 TIsiSend& aIsiMsg,
-TUint8 aMsgOffset ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsSbCommand");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSSBCOMMAND, "CMmSmsMessHandler::BuildSmsSbCommand" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSSBCOMMAND_TD, "CMmSmsMessHandler::BuildSmsSbCommand" );
 // Extract needed parameters from TPDU for SMS_SB_COMMAND
 TUint8 messageParameters( aMsgData[ KTpduIndexMessageParameters ] );
 TUint8 messageReference( aMsgData[ KTpduIndexMessageReference ] );
 TUint8 protocolId( aMsgData[ KTpduCommandIndexProtocolIdentifier ] );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbCommand. Message parameters: %d", messageParameters );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbCommand. Message reference: %d", messageReference );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbCommand. Protocol ID: %d", protocolId );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbCommand. Command type: %d", commandType );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbCommand. Message Number: %d", messageNumber );
-OstTraceExt5( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_BUILDSMSSBCOMMAND, "CMmSmsMessHandler::BuildSmsSbCommand;messageParameters=%hhu;messageReference=%hhu;protocolId=%hhu;commandType=%hhu;messageNumber=%hhu", messageParameters, messageReference, protocolId, commandType, messageNumber );
+OstTraceExt5( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_BUILDSMSSBCOMMAND_TD, "CMmSmsMessHandler::BuildSmsSbCommand;messageParameters=%hhu;messageReference=%hhu;protocolId=%hhu;commandType=%hhu;messageNumber=%hhu", messageParameters, messageReference, protocolId, commandType, messageNumber );
-}
+return commandBuf.Length();
+}
-// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsSbAddress
 // Creates SMS_SB_ADDRESS subblock and appends it to ISI message
 // -----------------------------------------------------------------------------
-TUint8 CMmSmsMessHandler::BuildSmsSbAddress(
+TUint16 CMmSmsMessHandler::BuildSmsSbAddress(
 const TDesC8& aAddress,
 TIsiSend& aIsiMsg,
 TUint8 aAddressType,
-TUint8 aMsgOffset ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsSbAddress");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSSBADDRESS, "CMmSmsMessHandler::BuildSmsSbAddress" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSSBADDRESS_TD, "CMmSmsMessHandler::BuildSmsSbAddress" );
 TUint8 addressLength( aAddress.Length() );
-TUint8 subblockLength( 0 );
 // Create and fill SMS_SB_ADDRESS subblock
 TBuf8<SIZE_SMS_SB_ADDRESS + SMS_ADDRESS_MAX_LEN> addressBuf( 0 );
 TIsiSubBlock address(
 addressBuf,
 SMS_SB_ADDRESS,
 addressBuf.Append( addressLength );
 addressBuf.Append( aAddress );
 aIsiMsg.CopyData( aMsgOffset, address.CompleteSubBlock() );
-// Subblock length is needed for return value
-subblockLength = addressBuf.Length();
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbAddress. Address type: %d", aAddressType );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbAddress. Address length: %d", addressLength );
-OstTraceExt2( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_BUILDSMSSBADDRESS, "CMmSmsMessHandler::BuildSmsSbAddress;aAddressType=%hhu;addressLength=%hhu", aAddressType, addressLength );
+OstTraceExt2( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_BUILDSMSSBADDRESS_TD, "CMmSmsMessHandler::BuildSmsSbAddress;aAddressType=%hhu;addressLength=%hhu", aAddressType, addressLength );
 #ifdef _DEBUG
 for ( TInt i( 0 ); i < aAddress.Length(); i++ )
 {
 TFLOGSTRING3( "TSY:CMmSmsMessHandler::BuildSmsSbAddress. Address data[%d]: 0x%x", i, aAddress[i] );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_BUILDSMSSBADDRESS, "CMmSmsMessHandler::BuildSmsSbAddress;i=%hhu;aAddress[i]=%hhu", i, aAddress[i] );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_BUILDSMSSBADDRESS_TD, "CMmSmsMessHandler::BuildSmsSbAddress;i=%hhu;aAddress[i]=%hhu", i, aAddress[i] );
 }
 #endif // _DEBUG
-TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbAddress. Length of subblock: %d", subblockLength );
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_BUILDSMSSBADDRESS, "CMmSmsMessHandler::BuildSmsSbAddress;subblockLength=%hhu", subblockLength );
+return addressBuf.Length();
+}
-return subblockLength;
-}
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsSbUserData
-// -----------------------------------------------------------------------------
 // Creates SMS_SB_USER_DATA subblock and appends it to ISI message
 // -----------------------------------------------------------------------------
-TUint8 CMmSmsMessHandler::BuildSmsSbUserData(
+TUint16 CMmSmsMessHandler::BuildSmsSbUserData(
 const TDesC8& aMsgData,
 TIsiSend& aIsiMsg,
 TUint8 aTpUdl,
 TUint8 aTpUserDataIndex,
 TBool aDefaultAlphabet,
-TUint8 aMsgOffset ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsSbUserData");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSSBUSERDATA, "CMmSmsMessHandler::BuildSmsSbUserData" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSSBUSERDATA_TD, "CMmSmsMessHandler::BuildSmsSbUserData" );
 TUint8 dataLengthInOctets( 0 );
-TUint8 subblockLength( 0 );
 // If data is 7-bit, then TP-UDL is integer representation of
 // the number of septets within the TP-UD field
 if ( aDefaultAlphabet )
 {
 userDataBuf.Append( aTpUdl );
 userDataBuf.Append( dataBytes );
 aIsiMsg.CopyData( aMsgOffset, userData.CompleteSubBlock() );
-subblockLength = userDataBuf.Length();
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbUserData. User data length in octets: %d", dataLengthInOctets );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbUserData. User data character count: %d", aTpUdl );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_BUILDSMSSBUSERDATA, "CMmSmsMessHandler::BuildSmsSbUserData;dataLengthInOctets=%hhu;aTpUdl=%hhu", dataLengthInOctets, aTpUdl );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_BUILDSMSSBUSERDATA_TD, "CMmSmsMessHandler::BuildSmsSbUserData;dataLengthInOctets=%hhu;aTpUdl=%hhu", dataLengthInOctets, aTpUdl );
-TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbUserData. Length of subblock: %d", subblockLength );
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_BUILDSMSSBUSERDATA, "CMmSmsMessHandler::BuildSmsSbUserData;subblockLength=%hhu", subblockLength );
+return userDataBuf.Length();
+}
-return subblockLength;
-}
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsSbValidityPeriod
-// -----------------------------------------------------------------------------
 // Creates SMS_SB_VALIDITY_PERIOD subblock and appends it to ISI message
 // -----------------------------------------------------------------------------
-void CMmSmsMessHandler::BuildSmsSbValidityPeriod(
+TUint16 CMmSmsMessHandler::BuildSmsSbValidityPeriod(
 const TDesC8& aMsgData,
 TIsiSend& aIsiMsg,
 TUint8 aTpVpIndex,
 TUint8 aTpVpLength,
-TUint8 aMsgOffset ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsSbValidityPeriod");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD_TD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod" );
 // Extract validity period data bytes
 TPtrC8 tpVpData( aMsgData.Mid( aTpVpIndex, aTpVpLength ) );
 // Create and fill SMS_SB_VALIDITY_PERIOD subblock, max length is 12
 validityPeriodBuf.Append( tpVpData );
 aIsiMsg.CopyData( aMsgOffset, validityPeriod.CompleteSubBlock() );
 TFLOGSTRING2( "TSY:CMmSmsMessHandler::BuildSmsSbValidityPeriod. Validity period length: %d", aTpVpLength );
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod;aTpVpLength=%hhu", aTpVpLength );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD_TD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod;aTpVpLength=%hhu", aTpVpLength );
 #ifdef _DEBUG
 for ( TInt i( 0 ); i < aTpVpLength; i++ )
 {
 TFLOGSTRING3( "Validity period, byte[%d], 0x%x", i, tpVpData[i] );
-OstTraceExt2( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod;i=%hhu;tpVpData[i]=%hhu", i, tpVpData[i] );
+OstTraceExt2( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_BUILDSMSSBVALIDITYPERIOD_TD, "CMmSmsMessHandler::BuildSmsSbValidityPeriod;i=%hhu;tpVpData[i]=%hhu", i, tpVpData[i] );
 }
 #endif // _DEBUG
-}
+return validityPeriodBuf.Length();
-// -----------------------------------------------------------------------------
+}
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::BuildSmsCheckInfo
 // Creates SMS_SB_CHECK_INFO sub block with SMS_CHECK_DISABLE_FDN and appends it
 // to ISI message.
 // -----------------------------------------------------------------------------
-void CMmSmsMessHandler::BuildSmsCheckInfo(
+TUint16 CMmSmsMessHandler::BuildSmsCheckInfo(
 TIsiSend& aIsiMsg,
-TUint8 aMsgOffset ) const
+TUint aMsgOffset ) const
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::BuildSmsCheckInfo");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_BUILDSMSCHECKINFO, "CMmSmsMessHandler::BuildSmsCheckInfo" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_BUILDSMSCHECKINFO_TD, "CMmSmsMessHandler::BuildSmsCheckInfo" );
 // Create and fill SMS_SB_CHECK_INFO subblock.
 TBuf8<SIZE_SMS_SB_CHECK_INFO> checkInfoBuf;
 TIsiSubBlock checkInfo(
 checkInfoBuf,
 checkInfoBuf.Append( KSmsPadding );
 checkInfoBuf.Append( KSmsPadding );
 aIsiMsg.CopyData( aMsgOffset, checkInfo.CompleteSubBlock() );
+return checkInfoBuf.Length();
 }
 // -----------------------------------------------------------------------------
 // CMmSmsMessHandler::ProcessUiccMsg
 // Handles data received from UICC server
 TInt aStatus,
 TUint8 /*aDetails*/,
 const TDesC8& aFileData )
 {
 TFLOGSTRING3("TSY:CMmSmsMessHandler::ProcessUiccMsg, aTraId: %d, status: %d", aTraId, aStatus );
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_PROCESSUICCMSG, "CMmSmsMessHandler::ProcessUiccMsg;aTraId=%d", aTraId );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_PROCESSUICCMSG_TD, "CMmSmsMessHandler::ProcessUiccMsg;aTraId=%d", aTraId );
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_PROCESSUICCMSG, "CMmSmsMessHandler::ProcessUiccMsg;aStatus=%d", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_PROCESSUICCMSG_TD, "CMmSmsMessHandler::ProcessUiccMsg;aStatus=%d", aStatus );
 TInt ret( KErrNone );
 switch( aTraId )
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::ProcessUiccMsg - unknown transaction ID" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_PROCESSUICCMSG, "CMmSmsMessHandler::ProcessUiccMsg - unknown transaction ID" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_PROCESSUICCMSG_TD, "CMmSmsMessHandler::ProcessUiccMsg - unknown transaction ID" );
 break;
 }
 }
 return ret;
 TInt CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq(
 const TUint8 aRecordId,
 const TUiccTrId aTrId )
 {
 TFLOGSTRING3("TSY: CMmSmsMessHandler::UiccReadSMSReq, aTraId: %d, aRecordId: %d", aTrId, aRecordId );
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCREADSMSORSMSRECORDCOUNTREQ, "CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq;aTrId=%hhu;aRecordId=%hhu", aTrId, aRecordId );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCREADSMSORSMSRECORDCOUNTREQ_TD, "CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq;aTrId=%hhu;aRecordId=%hhu", aTrId, aRecordId );
 TUint8 serviceType( 0 );
 TInt ret( KErrNone );
 switch( aTrId )
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSReq - unknown transaction ID" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_UICCREADSMSORSMSRECORDCOUNTREQ, "CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq - unknown transaction ID" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_UICCREADSMSORSMSRECORDCOUNTREQ_TD, "CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq - unknown transaction ID" );
 ret = KErrUnknown;
 break;
 }
 }
 void CMmSmsMessHandler::UiccReadSMSResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSResp" );
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp" );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SimStSmsHandleReadCacheEntriesL -- cacheing iRecordId=%d", iRecordId );
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp;iRecordId=%hhu", iRecordId );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp;iRecordId=%hhu", iRecordId );
 if ( 0 != aFileData.Length() )
 {
 // add to cache
 RMobileSmsStore::TMobileGsmSmsEntryV1 smsData;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSResp - abort caching");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp - abort caching" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp - abort caching" );
 // else SIM suddenly removed ==> abort caching
 // or example SIM rejected (EFSA-6ZQ9K3).
 // SMS is on SIM, but we couldn't read it. Cache must be
 // invalidated
 // either done or failed
 if ( KErrNotReady != iSmsCache.Status() )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccReadSMSResp - Success or Error value of SMS cache read = %d",iSmsCache.Status() );
-OstTrace1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp;iSmsCache.Status()=%d", iSmsCache.Status() );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp;iSmsCache.Status()=%d", iSmsCache.Status() );
 TFLOGSTRING3("TSY: CMmSmsMessHandler::UiccReadSMSResp --- SMS CACHE READ DONE --- total=%d used=%d",iSmsCache.TotalEntries(), iSmsCache.UsedEntries() );
-OstTrace1( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp;iSmsCache.TotalEntries()=%d", iSmsCache.TotalEntries() );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp;iSmsCache.TotalEntries()=%d", iSmsCache.TotalEntries() );
 // there is a chance that EMobileSmsMessagingGetMessageStoreInfo
 // request is already on if so, then complete it here... if there is
 // no request on, then this is harmless..
 TUint8 numOfLoc( TUint8( iSmsCache.TotalEntries() ) );
 // if cache is up and a message was received while cacheing then resume
 if ( KErrNone == iSmsCache.Status() && iReceivedClass2ToBeReSent )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSResp -- resume SMS reception");
-OstTrace0( TRACE_NORMAL, DUP5_CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp -- resume SMS reception" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp -- resume SMS reception" );
 SmsReceiveMessageReq( SMS_RECEPTION_STORAGE_STATUS_UPDATE );
 iReceivedClass2ToBeReSent = EFalse;
 }
 }
 }
 void CMmSmsMessHandler::UiccReadSMSRespForComplete(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSRespForComplete" );
-//OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCREADSMSRESP, "CMmSmsMessHandler::UiccReadSMSResp;aStatus=%d;aFileData=%s", aStatus,aFileData );
+//OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCREADSMSRESP_TD, "CMmSmsMessHandler::UiccReadSMSResp;aStatus=%d;aFileData=%s", aStatus,aFileData );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccReadSMSRespForComplete -- cacheing iRecordId=%d", iRecordId );
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCREADSMSRESPFORCOMPLETE, "CMmSmsMessHandler::UiccReadSMSRespForComplete;iRecordId=%hhu", iRecordId );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCREADSMSRESPFORCOMPLETE_TD, "CMmSmsMessHandler::UiccReadSMSRespForComplete;iRecordId=%hhu", iRecordId );
 if ( 0 != aFileData.Length() )
 {
 // add to cache
 RMobileSmsStore::TMobileGsmSmsEntryV1 smsData;
 const RMobileSmsStore::TMobileGsmSmsEntryV1& aEntry,
 const TUint8 aRecordId
 )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccWriteSMSReq aRecordId: %d", aRecordId );
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCWRITESMSREQ, "CMmSmsMessHandler::UiccWriteSMSReq;aRecordId=%hhu", aRecordId );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCWRITESMSREQ_TD, "CMmSmsMessHandler::UiccWriteSMSReq;aRecordId=%hhu", aRecordId );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccWriteLinearFixed params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdWriteSMS;
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::UiccWriteSMSResp( TInt aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccWriteSMSResp aStatus: %d", aStatus );
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCWRITESMSRESP, "CMmSmsMessHandler::UiccWriteSMSResp;aStatus=%d", aStatus );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCWRITESMSRESP_TD, "CMmSmsMessHandler::UiccWriteSMSResp;aStatus=%d", aStatus );
 // Create Package
 CMmDataPackage package;
 if ( iSMSClass2Write )
 {
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 // After writing class2 SMS to SIM card, it has
 // to be read in case SIM SW has changed the contents
 TInt ret( UiccReadSMSOrSMSRecordCountReq( iSmsSlotLocation, ETrIdReadSMSForComplete ) );
 if ( KErrNone != ret )
 }
 }
 }
 else
 {
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 // After writing class2 SMS to SIM card, it has
 // to be read in case SIM SW has changed the contents
 TInt ret( UiccReadSMSOrSMSRecordCountReq( iSmsSlotLocation, ETrIdReadSMSForComplete ) );
 if ( KErrNone != ret )
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::GetNumOfEFSMSRecords( void )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetNumOfEFSMSRecords" );
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDS, "CMmSmsMessHandler::GetNumOfEFSMSRecords" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDS_TD, "CMmSmsMessHandler::GetNumOfEFSMSRecords" );
 TUint8 recordID( 0 );
 TUiccTrId trId( ETrIdReadSMSRecordCount );
 CMmSmsMessHandler::UiccReadSMSOrSMSRecordCountReq ( recordID,
 void CMmSmsMessHandler::GetNumOfEFSMSRecordsResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::GetNumOfEFSMSRecordsResp" );
-OstTraceExt2( TRACE_NORMAL, CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDSRESP, "CMmSmsMessHandler::GetNumOfEFSMSRecordsResp;aStatus=%d;aFileData=%s", aStatus, aFileData );
+OstTraceExt2( TRACE_NORMAL,  CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDSRESP_TD, "CMmSmsMessHandler::GetNumOfEFSMSRecordsResp;aStatus=%d;aFileData=%s", aStatus, aFileData );
 //Save number of SMS locations on SIM card
 TInt smsNumOfLoc( 0 );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 TFci fci( aFileData );
 smsNumOfLoc = fci.GetNumberOfRecords();
 }
 if ( smsNumOfLoc > 0 )
 {
 // got the total number or SIM SMS entries
 iSmsCache.SetTotalEntriesL( smsNumOfLoc );
 TFLOGSTRING2("TSY: CMmSmsMessHandler::SimStSmsGetNumOfLocRespL -- total number of locations on sim %d", iSmsCache.TotalEntries() );
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDSRESP, "CMmSmsMessHandler::GetNumOfEFSMSRecordsResp;iSmsCache.TotalEntries()=%d", iSmsCache.TotalEntries() );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_GETNUMOFEFSMSRECORDSRESP_TD, "CMmSmsMessHandler::GetNumOfEFSMSRecordsResp;iSmsCache.TotalEntries()=%d", iSmsCache.TotalEntries() );
 // now start reading entries one by one starting from record 1
 UiccReadSMSOrSMSRecordCountReq( 1, ETrIdReadSMS );
 }
 else
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::UiccDeleteSMSResp( TInt aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccDeleteSMSResp aStatus: %d", aStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_UICCDELETESMSRESP, "CMmSmsMessHandler::UiccDeleteSMSResp;aStatus=%d", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_UICCDELETESMSRESP_TD, "CMmSmsMessHandler::UiccDeleteSMSResp;aStatus=%d", aStatus );
 // Create Package
 CMmDataPackage package;
 TInt error( CMmStaticUtility::UICCCSCauseToEpocError( aStatus ) );
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::UiccDeleteAllSMSResp( TInt aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccDeleteSMSResp aStatus: %d", aStatus );
-OstTrace1( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCDELETEALLSMSRESP, "CMmSmsMessHandler::UiccDeleteAllSMSResp;aStatus=%d", aStatus );
+OstTrace1( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCDELETEALLSMSRESP_TD, "CMmSmsMessHandler::UiccDeleteAllSMSResp;aStatus=%d", aStatus );
 // Create Package
 CMmDataPackage package;
 TInt error( CMmStaticUtility::UICCCSCauseToEpocError( aStatus ) );
 TBool CMmSmsMessHandler::CheckSCTimestamp(
 const RMobileSmsStore::TMobileGsmSmsEntryV1& aEntry,
 const TTime& aScTime )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::CheckSCTimestamp");
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp" );
 TBool matchFound( EFalse );
 TInt offset( 1 ); // Message Reference position
 TInt messageReference( aEntry.iMsgData[offset] );
 // Destination address length is integer representation
 // Ignore this messsage if month or day are zero (should not happen)
 if ( ( 0 == scTimeStamp[1] ) || ( 0 == scTimeStamp[2] ) )
 {
 TFLOGSTRING("TSY:CMmSmsMessHandler::CheckSCTimestamp:Invalid timestamp found, ignored.");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp, Invalid timestamp found, ignored" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp, Invalid timestamp found, ignored" );
 matchFound = ETrue;
 }
 if ( !matchFound )
 {
 #ifdef _DEBUG
 // debug print
 TDateTime dt = simStoredTime.DateTime();
 TFLOGSTRING("TSY:CMmSmsMessHandler::CheckSCTimestamp:Message stored on SIM:");
-OstTrace0( TRACE_NORMAL, DUP2_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp, Message stored on SIM:" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp, Message stored on SIM:" );
 TFLOGSTRING2("    year=%d",dt.Year());
-OstTrace1( TRACE_NORMAL, DUP3_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Year=%d", dt.Year() );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Year=%d", dt.Year() );
 TFLOGSTRING2("    month=%d",dt.Month()+1);
-OstTrace1( TRACE_NORMAL, DUP4_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Month=%d", ( dt.Month() + 1 ) );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Month=%d", ( dt.Month() + 1 ) );
 TFLOGSTRING2("    day=%d",dt.Day()+1);
-OstTrace1( TRACE_NORMAL, DUP5_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Day=%d", ( dt.Day() + 1 ) );
+OstTrace1( TRACE_NORMAL,  DUP5_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Day=%d", ( dt.Day() + 1 ) );
 TFLOGSTRING2("    hour=%d",dt.Hour());
-OstTrace1( TRACE_NORMAL, DUP6_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Hour=%d", dt.Hour() );
+OstTrace1( TRACE_NORMAL,  DUP6_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Hour=%d", dt.Hour() );
 TFLOGSTRING2("    minute=%d",dt.Minute());
-OstTrace1( TRACE_NORMAL, DUP7_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Minute=%d", dt.Minute() );
+OstTrace1( TRACE_NORMAL,  DUP7_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Minute=%d", dt.Minute() );
 TFLOGSTRING2("    second=%d",dt.Second());
-OstTrace1( TRACE_NORMAL, DUP8_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Second=%d", dt.Second() );
+OstTrace1( TRACE_NORMAL,  DUP8_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Second=%d", dt.Second() );
 TFLOGSTRING2("    timezone difference=%d",simTimezoneDiff);
-OstTraceExt1( TRACE_NORMAL, DUP9_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;simTimezoneDiff=%hhd", simTimezoneDiff );
+OstTraceExt1( TRACE_NORMAL,  DUP9_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;simTimezoneDiff=%hhd", simTimezoneDiff );
 dt = aScTime.DateTime();
 TFLOGSTRING("TSY:CMmSmsMessHandler::CheckSCTimestamp:Message opened on client side:");
-OstTrace0( TRACE_NORMAL, DUP10_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp, Message opened on client side:" );
+OstTrace0( TRACE_NORMAL,  DUP10_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp, Message opened on client side:" );
 TFLOGSTRING2("    year=%d",dt.Year());
-OstTrace1( TRACE_NORMAL, DUP11_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Year=%d", ( dt.Year() + 1 ) );
+OstTrace1( TRACE_NORMAL,  DUP11_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Year=%d", ( dt.Year() + 1 ) );
 TFLOGSTRING2("    month=%d",dt.Month()+1);
-OstTrace1( TRACE_NORMAL, DUP12_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Month=%d", ( dt.Month() + 1 ) );
+OstTrace1( TRACE_NORMAL,  DUP12_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Month=%d", ( dt.Month() + 1 ) );
 TFLOGSTRING2("    day=%d",dt.Day()+1);
-OstTrace1( TRACE_NORMAL, DUP13_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Day=%d", ( dt.Day() + 1 ) );
+OstTrace1( TRACE_NORMAL,  DUP13_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Day=%d", ( dt.Day() + 1 ) );
 TFLOGSTRING2("    hour=%d",dt.Hour());
-OstTrace1( TRACE_NORMAL, DUP14_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Hour=%d", dt.Hour() );
+OstTrace1( TRACE_NORMAL,  DUP14_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Hour=%d", dt.Hour() );
 TFLOGSTRING2("    minute=%d",dt.Minute());
-OstTrace1( TRACE_NORMAL, DUP15_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Minute=%d", dt.Minute() );
+OstTrace1( TRACE_NORMAL,  DUP15_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Minute=%d", dt.Minute() );
 TFLOGSTRING2("    second=%d",dt.Second());
-OstTrace1( TRACE_NORMAL, DUP16_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP, "CMmSmsMessHandler::CheckSCTimestamp;Second=%d", dt.Second() );
+OstTrace1( TRACE_NORMAL,  DUP16_CMMSMSMESSHANDLER_CHECKSCTIMESTAMP_TD, "CMmSmsMessHandler::CheckSCTimestamp;Second=%d", dt.Second() );
 // debug print
 #endif // _DEBUG
 if ( simStoredTime == aScTime )
 {
 TInt CMmSmsMessHandler::UiccUpdateSMSStatus(
 const TUint8 aRecordId
 )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccUpdateSMSStatusReq aRecordId: %d", aRecordId );
-OstTraceExt1( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCUPDATESMSSTATUS, "CMmSmsMessHandler::UiccUpdateSMSStatus;aRecordId=%hhu", aRecordId );
+OstTraceExt1( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCUPDATESMSSTATUS_TD, "CMmSmsMessHandler::UiccUpdateSMSStatus;aRecordId=%hhu", aRecordId );
 // Read parameters from SIM
 // Set parameters for UICC_APPL_CMD_REQ message
 iRecordId = aRecordId;
 TUiccReadLinearFixed params;
 void CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccReadSMSResp" );
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCUPDATESMSSTATUSREADSMSRESP, "CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCUPDATESMSSTATUSREADSMSRESP_TD, "CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp" );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 if ( 0 != aFileData.Length() )
 {
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccWriteLinearFixed params;
 // -----------------------------------------------------------------------------
 //
 void CMmSmsMessHandler::UiccUpdateSMSStatusWriteSMSResp( TInt aStatus )
 {
 TFLOGSTRING2("TSY: CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp aStatus: %d", aStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_UICCUPDATESMSSTATUSREADSMSRESP, "CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp;aStatus=%d", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_UICCUPDATESMSSTATUSREADSMSRESP_TD, "CMmSmsMessHandler::UiccUpdateSMSStatusReadSMSResp;aStatus=%d", aStatus );
 iMessageRouter->Complete(
 ECustomSetSimMessageStatusReadIPC,
 CMmStaticUtility::UICCCSCauseToEpocError( aStatus )  );
 // Update the same flag also in TSY's cache.
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 iSmsCache.SetStorageStatus( iRecordId, RMobileSmsStore::EStoredMessageRead );
 }
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::UiccGetSmspEntryReq()
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccGetSmspEntryReq" );
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCREADNUMOFSMSPENTRIES, "CMmSmsMessHandler::UiccGetSmspEntryReq" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCREADNUMOFSMSPENTRIES_TD, "CMmSmsMessHandler::UiccGetSmspEntryReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadLinearFixed params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdGetSmspEntries;
 // -----------------------------------------------------------------------------
 //
 TInt CMmSmsMessHandler::UiccStoreSmspEntry( const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccStoreSmspEntry" );
-OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_UICCSTORESMSPENTRY, "CMmSmsMessHandler::UiccStoreSmspEntry" );
+OstTrace0( TRACE_NORMAL,  CMMSMSMESSHANDLER_UICCSTORESMSPENTRY_TD, "CMmSmsMessHandler::UiccStoreSmspEntry" );
 TInt ret( KErrNone );
 TInt dataLength( aFileData.Length() );
 TPtrC8 data( KNullDesC8 );
 TSmsParameters* smsParam = new ( ELeave ) TSmsParameters();
 //
 TInt CMmSmsMessHandler::UiccSmsUpdateParameterReq(
 const CMmDataPackage* aDataPackage )
 {
 TFLOGSTRING("TSY: CMmSmsMessHandler::UiccSmsUpdateParameterReq");
-OstTrace0( TRACE_NORMAL, DUP1_CMMSMSMESSHANDLER_UICCSTORESMSPENTRY, "CMmSmsMessHandler::UiccStoreSmspEntry" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMSMSMESSHANDLER_UICCSTORESMSPENTRY_TD, "CMmSmsMessHandler::UiccStoreSmspEntry" );
 RMobileSmsMessaging::TMobileSmspEntryV1* smsParameters;
 // Unpack data
 aDataPackage->UnPackData( &smsParameters );
 params.fileData.Append( smspBuffer );
 return iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::SmsResourceConfInd
+// -----------------------------------------------------------------------------
+//
+void CMmSmsMessHandler::SmsResourceConfInd( const TIsiReceiveC& aIsiMsg )
+{
+TFLOGSTRING( "TSY: CMmSmsMessHandler::SmsResourceConfInd" );
+OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRESOURCECONFIND_TD, "CMmSmsMessHandler::SmsResourceConfInd" );
+// To check The receive indication is for startup or reconfiguration
+if ( SMS_RES_CONF_STARTUP == aIsiMsg.Get8bit(
+ISI_HEADER_SIZE + SMS_RESOURCE_CONF_IND_OFFSET_CONFSTATUS ) )
+{
+TUint sbStartOffset( 0 );
+// Check if resource control is requested for MO SM.
+if ( KErrNone == aIsiMsg.FindSubBlockOffsetById(
+ISI_HEADER_SIZE + SIZE_SMS_RESOURCE_CONF_IND,
+SMS_SB_RESOURCE_CONF_REQUIRED,
+EIsiSubBlockTypeId16Len16,
+sbStartOffset ) )
+{
+TUint16 resource( aIsiMsg.Get16bit(
+sbStartOffset + SMS_SB_RESOURCE_CONF_REQUIRED_OFFSET_RESPP ) );
+// Check MO SMS control is supported by SIM service table
+if ( SMS_RES_ID_CONF_MO_SM_INIT == resource &&
+NULL == iPhonetReceiver->SatMessHandler() )
+{
+SmsResourceConfReq();
+}
+}
+}
+}
+// -----------------------------------------------------------------------------
+// CMmSmsMessHandler::SmsResourceConfReq
+// -----------------------------------------------------------------------------
+//
+void CMmSmsMessHandler::SmsResourceConfReq()
+{
+TFLOGSTRING("TSY: CMmSmsMessHandler::SmsResourceConfReq");
+OstTrace0( TRACE_NORMAL, CMMSMSMESSHANDLER_SMSRESOURCECONFREQ_TD, "CMmSmsMessHandler::SmsResourceConfReq" );
+TBuf8<SIZE_SMS_SB_RESOURCE_CONF> data;
+TIsiSubBlock ResourceConfReqSb(
+data,
+SMS_SB_RESOURCE_CONF,
+EIsiSubBlockTypeId16Len16 );
+// set SMS_RESOURCE_IDS to SMS_RES_ID_MO_SM_INIT_DISABLE
+data.Append( KSmsResIdMoSmInitDisable >> KShift8 );
+data.Append( KSmsResIdMoSmInitDisable );
+// set SMS_RESOURCE_IDS_MASK to SMS_RES_ID_MASK_MO_SM_INIT
+data.Append( SMS_RES_ID_MASK_MO_SM_INIT >> KShift8 );
+data.Append( SMS_RES_ID_MASK_MO_SM_INIT );
+// Create SMS_RESOURCE_CONF_REQ message
+TIsiSend isiMsg( iPhoNetSender->SendBufferDes() );
+isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_SMS );
+isiMsg.Set8bit(
+ISI_HEADER_SIZE + SMS_RESOURCE_CONF_REQ_OFFSET_TRANSID,
+0 );
+isiMsg.Set8bit(
+ISI_HEADER_SIZE + SMS_RESOURCE_CONF_REQ_OFFSET_MESSAGEID,
+SMS_RESOURCE_CONF_REQ );
+isiMsg.Set8bit(
+ISI_HEADER_SIZE + SMS_RESOURCE_CONF_REQ_OFFSET_CONFOPERATION,
+SMS_RES_CONF_SET );
+isiMsg.Set8bit(
+ISI_HEADER_SIZE + SMS_RESOURCE_CONF_REQ_OFFSET_SUBBLOCKCOUNT,
+1 );
+isiMsg.CopyData(
+ISI_HEADER_SIZE + SIZE_SMS_RESOURCE_CONF_REQ,
+ResourceConfReqSb.CompleteSubBlock() );
+iPhoNetSender->Send( isiMsg.Complete() );
+}
 //  End of File

changeset 9	8486d82aef45
parent 8	6295dc2169f3