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

equal deleted inserted replaced

-:6295dc2169f3
+:8486d82aef45
 #include <call_modemisi.h>      // Call Modem server
 #include <smsisi.h>             // sms server
 #include <uiccisi.h>            // UICC server
 #include <gpdsisi.h>            // GPDS server
-#include <atk_sharedisi.h>
 #include <call_sharedisi.h>
 #include <info_sharedisi.h>
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "satmesshandlerTraces.h"
 const TInt KNoTransactionOngoing                = -1;
 // Time zone not available
 const TUint8 KTimeZoneNotAvailable              = 0xFF;
 // Access Technology unknown
 const TUint8 KAccTechUnknown                    = 0xFF;
-// This is a common length constant (2 bytes)
-const TUint8 KLengthTwoBytes                    = 0x02;
 // Maximum polling interval of legacy phones
 const TUint8 KMaxLegacyPollInterval             = 0x19; // 25 decimal
 // Size of one clut entry in bytes
 const TUint16 KClutEntrySize                    = 3;
 )
 :
 iTsySatMessaging( aTsySatMessaging ),
 iPnSend( aPnSend )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CSATMESSHANDLER, "CSatMessHandler::CSatMessHandler" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CSATMESSHANDLER_TD, "CSatMessHandler::CSatMessHandler" );
 // >= 0 if there is ongoing transaction
 iTerminalRespTraId              = KNoTransactionOngoing;
 iGetIconSimReadFieldTraId       = KNoTransactionOngoing;
 iDataDownloadSimReadFieldTraId  = KNoTransactionOngoing;
+iCbRoutingReqTraId              = KNoTransactionOngoing;
 iCardId                         = KZero;
 iImeiAvailable                  = EFalse;
 iImeiSvAvailable                = EFalse;
 // By default, there's no need to request routing from SMS server
 // Destructor.
 // -----------------------------------------------------------------------------
 //
 CSatMessHandler::~CSatMessHandler()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_CSATMESSHANDLER, "CSatMessHandler::~CSatMessHandler" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_CSATMESSHANDLER_TD, "CSatMessHandler::~CSatMessHandler" );
 }
 // -----------------------------------------------------------------------------
 // CSatMessHandler::NewL
 // Two-phased constructor.
 (
 CTsySatMessaging*   aTsySatMessaging,
 CMmPhoNetSender*    aPnSend
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NEWL, "CSatMessHandler::NewL" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NEWL_TD, "CSatMessHandler::NewL" );
 TFLOGSTRING("TSY:CSatMessHandler::NewL");
 CSatMessHandler* self = new( ELeave ) CSatMessHandler( aTsySatMessaging,
 aPnSend );
 CleanupStack::PushL( self );
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::ConstructL()
 {
 TFLOGSTRING("TSY:CSatMessHandler::ConstructL");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CONSTRUCTL, "CSatMessHandler::ConstructL" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CONSTRUCTL_TD, "CSatMessHandler::ConstructL" );
 // This flag is set to 'true' when indication ESatUsatClientReadyIndication
 // is received from SAT server. CAT can be enabled when the state of this
 // flag is 'true' and also UICC server is ready.
 iSatReady = EFalse;
 void CSatMessHandler::ProactiveProcedureMessageReceivedL
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PROACTIVEPROCEDUREMESSAGERECEIVEDL, "CSatMessHandler::ProactiveProcedureMessageReceivedL" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_PROACTIVEPROCEDUREMESSAGERECEIVEDL_TD, "CSatMessHandler::ProactiveProcedureMessageReceivedL" );
 TFLOGSTRING("TSY:CSatMessHandler::ProactiveProcedureMessageReceivedL");
 // handle event download and related messages
 iTsySatMessaging->EventDownloadReceived( aIsiMessage );
 void CSatMessHandler::NetServerMessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETSERVERMESSAGERECEIVED, "CSatMessHandler::NetServerMessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETSERVERMESSAGERECEIVED_TD, "CSatMessHandler::NetServerMessageReceived" );
 TFLOGSTRING("TSY:CSatMessHandler::NetServerMessageReceived");
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 switch ( messageId )
 // during the first request.
 if ( !iSmsCbRoutingComplete )
 {
 TFLOGSTRING("TSY:CSatMessHandler::NetServerMessageReceived \
 Sending delayed SMS CB routing request.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_NETSERVERMESSAGERECEIVED, "CSatMessHandler::NetServerMessageReceived Sending delayed SMS CB routing request." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_NETSERVERMESSAGERECEIVED_TD, "CSatMessHandler::NetServerMessageReceived Sending delayed SMS CB routing request." );
 SmsCbRoutingReq(
 iTsySatMessaging->GetTransactionId(), SMS_ROUTING_SET );
 }
 break;
 }
 }
 }
 }
 // -----------------------------------------------------------------------------
-// CSatMessHandler::PhoneInfoMessageReceived
+// CSatMessHandler::PhoneInfoMessageReceivedL
 // Called from SatMessHandler::ReceivedL, handles Phone Info related messages
 // -----------------------------------------------------------------------------
 //
-void CSatMessHandler::PhoneInfoMessageReceived
+/*void CSatMessHandler::PhoneInfoMessageReceivedL
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PHONEINFOMESSAGERECEIVED, "CSatMessHandler::PhoneInfoMessageReceived" );
+OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PHONEINFOMESSAGERECEIVEDL_TD, "CSatMessHandler::PhoneInfoMessageReceivedL" );
-TFLOGSTRING("TSY:CSatMessHandler::PhoneInfoMessageReceived");
+TFLOGSTRING("TSY:CSatMessHandler::PhoneInfoMessageReceivedL");
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 switch ( messageId )
 {
 InfoSerialNumberReadResp( aIsiMessage );
 break;
 }
 case INFO_PP_READ_RESP:
 {
-InfoPpReadResp( aIsiMessage );
+InfoPpReadRespL( aIsiMessage );
 break;
 }
 default:
 {
 // do nothing
 break;
 }
 }
-}
+}*/
 // -----------------------------------------------------------------------------
 // CSatMessHandler::UiccServerMessageReceived
 // Called from SatMessHandler::ReceivedL, handles UICC Server messages
 // -----------------------------------------------------------------------------
 //
-TBool CSatMessHandler::UiccServerMessageReceived(
+TBool CSatMessHandler::UiccServerMessageReceivedL(
 const TIsiReceiveC& aIsiMessage )
 {
 TUint8 messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
-OstTraceExt1( TRACE_NORMAL, DUP3_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVED, "CSatMessHandler::UiccServerMessageReceived;messageId=%hhu", messageId );
+OstTraceExt1( TRACE_NORMAL, DUP3_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVEDL_TD, "CSatMessHandler::UiccServerMessageReceived;messageId=%hhu", messageId );
-TFLOGSTRING2("TSY:CSatMessHandler::UiccServerMessageReceived, message ID: %d", messageId );
+TFLOGSTRING2("TSY:CSatMessHandler::UiccServerMessageReceivedL, message ID: %d", messageId );
 TBool handled( EFalse );
 switch ( messageId )
 {
 case UICC_CAT_IND:
 {
-UiccCatInd( aIsiMessage );
+UiccCatIndL( aIsiMessage );
 break;
 }
 case UICC_CAT_RESP:
 {
 TUint8 serviceType(
 TUint8 status(
 aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + UICC_CAT_RESP_OFFSET_STATUS ) );
 TFLOGSTRING3("TSY:CSatMessHandler:: KUiccCatResp: service type %d, status %d", serviceType, status);
-OstTraceExt2( TRACE_NORMAL, DUP2_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVED, "CSatMessHandler::KUiccCatResp;serviceType=%hhu;status=%hhu", serviceType, status );
+OstTraceExt2( TRACE_NORMAL, DUP2_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVEDL_TD, "CSatMessHandler::KUiccCatResp;serviceType=%hhu;status=%hhu", serviceType, status );
 // If terminal profile was sent succesfully and SAT is ready,
 // start fetching proactive commands
 if ( UICC_CAT_TERMINAL_PROFILE == serviceType &&
 UICC_STATUS_OK == status )
 }
 }
 // Response for refresh command
 else if ( UICC_CAT_REFRESH == serviceType )
 {
-RefreshResult( status );
+RefreshResultL( status );
 }
 // Response for polling set command
 else if ( UICC_CAT_POLLING_SET == serviceType  )
 {
 SetPollingResult(
 // Access to UICC files is possible when application is active
 TUint8 serviceType( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + UICC_APPLICATION_IND_OFFSET_SERVICETYPE ) );
 if ( UICC_APPL_ACTIVATED == serviceType )
 {
-// USIM and SIM: Read SMS-PP DD and Call Control from byte 4.
+TInt ret( KErrNone );
-// Only USIM: MO-SMS control from byte 4
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
 if ( UICC_CARD_TYPE_UICC == iCardType )
 {
+// USIM: Read SMS-PP DD, Call Control and MO-SMS control from byte 4.
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
+User::LeaveIfError( ret );
 // USIM: Read call control GPRS from byte 7
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte7, 6 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte7, 6 );
+User::LeaveIfError( ret );
 }
 else if ( UICC_CARD_TYPE_ICC == iCardType )
 {
-// SIM: Read MO-SMS control from byte 5
+// SIM: Read MO-SMS control from byte 10
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte5, 4 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte10, 9 );
+User::LeaveIfError( ret );
+// SIM: Read SMS-PP DD and Call Control from byte 7
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte7, 6 );
+User::LeaveIfError( ret );
+// SIM: Read Call control in USSD from byte 11. This is supported only in SIM
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte11, 10 );
+User::LeaveIfError( ret );
 }
 }
 break;
 }
 case UICC_APPL_CMD_RESP:
 void CSatMessHandler::SmsServerMessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message from SMS server
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SMSSERVERMESSAGERECEIVED, "CSatMessHandler::SmsServerMessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SMSSERVERMESSAGERECEIVED_TD, "CSatMessHandler::SmsServerMessageReceived" );
 TFLOGSTRING("TSY:CSatMessHandler::SmsServerMessageReceived");
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 switch ( messageId )
 }
 case SMS_RESOURCE_CONF_RESP:
 {
 // Take a log because result is always ok
 TFLOGSTRING("TSY:CSatMoSmsCtrl::SmsResourceConfRespReceived: Response for Resource confoguration Req, Receive response from SMS server");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMOSMSCTRL_SMSRESOURCECONFRESPRECEIVED, "CSatMoSmsCtrl::SmsResourceRespReceived: Response for Resource Configuration Req, Receive response from SMS server" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMOSMSCTRL_SMSRESOURCECONFRESPRECEIVED_TD, "CSatMoSmsCtrl::SmsResourceRespReceived: Response for Resource Configuration Req, Receive response from SMS server" );
 break;
 }
 default:
 // do nothing
 break;
 void CSatMessHandler::SsServerMessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SSSERVERMESSAGERECEIVED, "CSatMessHandler::SsServerMessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SSSERVERMESSAGERECEIVED_TD, "CSatMessHandler::SsServerMessageReceived" );
 TFLOGSTRING("TSY:CSatMessHandler::SsServerMessageReceived");
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 switch ( messageId )
 void CSatMessHandler::GsmStackServerMessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GSMSTACKSERVERMESSAGERECEIVED, "CSatMessHandler::GsmStackServerMessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GSMSTACKSERVERMESSAGERECEIVED_TD, "CSatMessHandler::GsmStackServerMessageReceived" );
 TFLOGSTRING("TSY:CSatMessHandler::GsmStackServerMessageReceived");
 switch ( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )
 {
 case GSS_CS_SERVICE_RESP:
 TDes8& aCommandDetails,     // PCmd number
 TUint8 aGeneralResult,      // General Result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_DISPLAYTEXTTERMINALRESP, "CSatMessHandler::DisplayTextTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_DISPLAYTEXTTERMINALRESP_TD, "CSatMessHandler::DisplayTextTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::DisplayTextTerminalResp");
 TTlv tlvSpecificData;
 // Create General Result TLV here
 tlvSpecificData.AddTag( KTlvResultTag );
 const TUint8 aTransId,            // Transaction id
 const TDes8& aCommandDetails,     // PCmd number
 const RSat::TGetInkeyRspV2& aRsp  // Response packet from Etel
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETINKEYTERMINALRESP, "CSatMessHandler::GetInkeyTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETINKEYTERMINALRESP_TD, "CSatMessHandler::GetInkeyTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::GetInkeyTerminalRespL");
 TTlv tlvSpecificData;
 //General result
 TUint8 aAdditionalInfo,     // Additional info
 TDesC16& aTextString,       // Response string
 TUint8 aDataCodingScheme    // Coding scheme
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETINPUTTERMINALRESP, "CSatMessHandler::GetInputTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETINPUTTERMINALRESP_TD, "CSatMessHandler::GetInputTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::GetInputTerminalResp");
 TTlv tlvSpecificData;
 TBuf8<KGetInputStringMaxSize> string;
 TDes8& aCommandDetails,     // Command details
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PLAYTONETERMINALRESP, "CSatMessHandler::PlayToneTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_PLAYTONETERMINALRESP_TD, "CSatMessHandler::PlayToneTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::PlayToneTerminalResp");
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TDes8& aCommandDetails,     // aPCmdNumber
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETUPMENUTERMINALRESP, "CSatMessHandler::SetUpMenuTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETUPMENUTERMINALRESP_TD, "CSatMessHandler::SetUpMenuTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SetUpMenuTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 TDes8& aCommandDetails,     // Comamnd number
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SELECTITEMTERMINALRESP, "CSatMessHandler::SelectItemTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SELECTITEMTERMINALRESP_TD, "CSatMessHandler::SelectItemTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SelectItemTerminalResp");
 TTlv tlvSpecificData;
 // Create general result TLV here
 tlvSpecificData.AddTag( KTlvResultTag );
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo,     // Additional info
 TUint8 aNumOfUnits          // Time interval
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_POLLINTERVALTERMINALRESP, "CSatMessHandler::PollIntervalTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_POLLINTERVALTERMINALRESP_TD, "CSatMessHandler::PollIntervalTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::PollIntervalTerminalResp");
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TDes8& aCommandDetails,     // Command details
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDSMTERMINALRESP, "CSatMessHandler::SendSmTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDSMTERMINALRESP_TD, "CSatMessHandler::SendSmTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SendSmTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 TDes8&  aCommandDetails,    // Command details tlv
 TUint8  aGeneralResult,     // General result
 TDesC8& aAdditionalInfo     // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDSSTERMINALRESP, "CSatMessHandler::SendSsTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDSSTERMINALRESP_TD, "CSatMessHandler::SendSsTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SendSsTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TDes8& aCommandDetails,
 TUint8  aGeneralResult,     // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDDTMFTERMINALRESP, "CSatMessHandler::SendDtmfTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDDTMFTERMINALRESP_TD, "CSatMessHandler::SendDtmfTerminalResp" );
 TFLOGSTRING("CSatMessHandler::SendDtmfTerminalResp");
 TTlv tlvSpecificData;
 // Append general result tag
 tlvSpecificData.AddTag( KTlvResultTag );
 TUint8 aAdditionalInfo,
 TDes& aUssdData,
 TUint8  aUssdCbsDataCodingScheme
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDUSSDTERMINALRESP, "CSatMessHandler::SendUssdTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDUSSDTERMINALRESP_TD, "CSatMessHandler::SendUssdTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SendUssdTerminalResp");
 TTlv tlvSpecificData;
 TBuf8<RSat::KStringMaxSize> string;
 tlvSpecificData.AddTag( KTlvResultTag );
 tlvSpecificData.AddByte( aGeneralResult );
-// For the general results '20', '21', '37', '38'
+// For the general results '20', '21', '37', '38', '39'
 // it is mandatory for the ME to provide a specific
 // cause value as additional
 if ( ( RSat::KMeUnableToProcessCmd == aGeneralResult )
 || ( RSat::KNetworkUnableToProcessCmd == aGeneralResult )
 || ( RSat::KUssdReturnError == aGeneralResult)
-|| ( RSat::KMultipleCardCmdsError == aGeneralResult) )
+|| ( RSat::KMultipleCardCmdsError == aGeneralResult)
+|| ( RSat::KInteractionWithCCPermanentError == aGeneralResult ) )
 {
 tlvSpecificData.AddByte( aAdditionalInfo );
 }
 // For general result '32' additional info or text string is not used
 else if ( RSat::KCmdDataNotUnderstood != aGeneralResult )
 // Reserved
 // The general result should in fact prevent reaching this
 // branch of the switch.
 TFLOGSTRING("TSY:CSatMessHandler::SendUssdTerminalResp, \
 The DCS sent by the network has a reserved value.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_SENDUSSDTERMINALRESP, "CSatMessHandler::SendUssdTerminalResp, The DCS sent by the network has a reserved value." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_SENDUSSDTERMINALRESP_TD, "CSatMessHandler::SendUssdTerminalResp, The DCS sent by the network has a reserved value." );
 break;
 }
 }
 // Text
 tlvSpecificData.AddData( string );
 TDes8& aCommandDetails,     // Command Details tlv
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETUPCALLTERMINALRESP, "CSatMessHandler::SetUpCallTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETUPCALLTERMINALRESP_TD, "CSatMessHandler::SetUpCallTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SetUpCallTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TDes8& aCommandDetails,     // Command number
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_REFRESHTERMINALRESP, "CSatMessHandler::RefreshTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_REFRESHTERMINALRESP_TD, "CSatMessHandler::RefreshTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::RefreshTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 // append result tag
 TUint8 aTransId,        // Transaction id
 TUint8 aItemIdentifier, // Item identifier
 TUint8 aHelp            // Help requested status
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_MENUSELECTIONIND, "CSatMessHandler::MenuSelectionInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_MENUSELECTIONIND_TD, "CSatMessHandler::MenuSelectionInd" );
 TFLOGSTRING("TSY:CSatMessHandler::MenuSelectionInd");
 TTlv tlvSpecificData;
 tlvSpecificData.Begin( KBerTlvMenuSelectionTag );
 TDes8& aCommandDetails, // command number
 TUint8 aGeneralResult,  // Result
 TUint8 aAdditionalInfo  // additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_LAUNCHBROWSERTERMINALRESP, "CSatMessHandler::LaunchBrowserTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_LAUNCHBROWSERTERMINALRESP_TD, "CSatMessHandler::LaunchBrowserTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::LaunchBrowserTerminalResp");
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TBool CSatMessHandler::CommandPerformedSuccessfully
 (
 TUint8 aGeneralResult
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_COMMANDPERFORMEDSUCCESSFULLY, "CSatMessHandler::CommandPerformedSuccessfully" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_COMMANDPERFORMEDSUCCESSFULLY_TD, "CSatMessHandler::CommandPerformedSuccessfully" );
 TFLOGSTRING("TSY:CSatMessHandler::CommandPerformedSuccessfully");
 TBool ret( EFalse );
 switch ( aGeneralResult )
 {
 TDes8& aCommandDetails,     // command number
 TUint8 aGeneralResult,      // Result
 TUint8 aAdditionalInfo      // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETUPIDLEMODETEXTTERMINALRESP, "CSatMessHandler::SetUpIdleModeTextTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETUPIDLEMODETEXTTERMINALRESP_TD, "CSatMessHandler::SetUpIdleModeTextTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SetUpIdleModeTextTerminalResp");
 TTlv tlvSpecificData;
 //create General Result TLV here
 TUint8 aTransId,
 const TDesC8& aBerTlv,  // BER-TLV specific data
 TBool aStore            // Is envelope stored for resending
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATREQENVELOPE, "CSatMessHandler::UiccCatReqEnvelope" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATREQENVELOPE_TD, "CSatMessHandler::UiccCatReqEnvelope" );
 TFLOGSTRING("TSY:CSatMessHandler::UiccCatReqEnvelope");
 TIsiSend isiMsg( iPnSend->SendBufferDes() );
 isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );
 isiMsg.Set8bit(
 TInt CSatMessHandler::StoreNetServiceStatus
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_STORENETSERVICESTATUS, "CSatMessHandler::StoreNetServiceStatus" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_STORENETSERVICESTATUS_TD, "CSatMessHandler::StoreNetServiceStatus" );
 TFLOGSTRING("TSY: CSatMessHandler::StoreNetServiceStatus");
 // SubBlock offset
 TUint sbOffset( 0 );
 // Get registration status value
 iLocInfo.iRegStatus = aIsiMessage.Get8bit(
 sbOffset + NET_GSM_CELL_INFO_OFFSET_SERVICESTATUS );
 TFLOGSTRING2("TSY: CSatMessHandler::StoreNetServiceStatus: NET_REGISTRATION_STATUS = %d", iLocInfo.iRegStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_STORENETSERVICESTATUS, "CSatMessHandler::StoreNetServiceStatus NET_REGISTRATION_STATUS = %d", iLocInfo.iRegStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_STORENETSERVICESTATUS_TD, "CSatMessHandler::StoreNetServiceStatus NET_REGISTRATION_STATUS = %d", iLocInfo.iRegStatus );
 if ( NET_SERVICE == iLocInfo.iRegStatus ||
 NET_LIMITED_SERVICE == iLocInfo.iRegStatus )
 {
 // Get country code
 }
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::StoreNetServiceStatus - NET_GSM_CELL_INFO or NET_WCDMA_CELL_INFO not found!");
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_STORENETSERVICESTATUS, "CSatMessHandler::StoreNetServiceStatus NET_GSM_CELL_INFO or NET_WCDMA_CELL_INFO not found!" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_STORENETSERVICESTATUS_TD, "CSatMessHandler::StoreNetServiceStatus NET_GSM_CELL_INFO or NET_WCDMA_CELL_INFO not found!" );
 retValue = KErrNotFound;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CSatMessHandler::StoreNetServiceStatus - Unexpected message id: %d", messageId );
-OstTrace1( TRACE_NORMAL, DUP3_CSATMESSHANDLER_STORENETSERVICESTATUS, "CSatMessHandler::StoreNetServiceStatus Unexpected message id: %d", messageId );
+OstTrace1( TRACE_NORMAL,  DUP3_CSATMESSHANDLER_STORENETSERVICESTATUS_TD, "CSatMessHandler::StoreNetServiceStatus Unexpected message id: %d", messageId );
 retValue = KErrNotFound;
 }
 return retValue;
 TDes8& aCommandDetails,      // Command details
 TUint8 aGeneralResult,       // General result
 TUint8 aAdditionalInfo       // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETUPEVENTLISTTERMINALRESP, "CSatMessHandler::SetUpEventListTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETUPEVENTLISTTERMINALRESP_TD, "CSatMessHandler::SetUpEventListTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SetUpEventListTerminalResp");
 // create responce data
 TTlv tlvSpecificData;
 //create General Result TLV here
 TDes8& aCommandDetails,         // Transaction id
 TUint8 aGeneralResult,          // General result
 TUint8 aAdditionalInfo          // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_POLLINGOFFTERMINALRESP, "CSatMessHandler::PollingOffTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_POLLINGOFFTERMINALRESP_TD, "CSatMessHandler::PollingOffTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::PollingOffTerminalResp");
 TTlv tlvSpecificData;
 tlvSpecificData.AddTag( KTlvResultTag );
 TDes8& aCommandDetails,     // Command details tlv
 TUint8 aGeneralResult,      // General result
 TDes& aAdditionalInfo       // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_LOCALINFOTERMINALRESP, "CSatMessHandler::LocalInfoTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_LOCALINFOTERMINALRESP_TD, "CSatMessHandler::LocalInfoTerminalResp" );
 TFLOGSTRING("TSY: CSatMessHandler::LocalInfoTerminalResp");
 // Create and append response data
 TTlv tlvData;
 // Create General Result TLV
 tlvData.AddTag( KTlvResultTag );
 }
 case RSat::KProvideLocalInfoTimingAdv:
 {
 TFLOGSTRING("TSY: CSatMessHandler::LocalInfoTerminalResp,\
 TimingAdvance");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_LOCALINFOTERMINALRESP, "CSatMessHandler::LocalInfoTerminalResp, TimingAdvance" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_LOCALINFOTERMINALRESP_TD, "CSatMessHandler::LocalInfoTerminalResp, TimingAdvance" );
 // Timing advance result
 tlvData.AddTag( KTlvTimingAdvanceTag );
 tlvData.AddByte( iTaStatus );
 tlvData.AddByte( iTimingAdvance );
 }
 case RSat::KProvideLocalInfoLanguage:
 {
 TFLOGSTRING("TSY: CSatMessHandler::LocalInfoTerminalResp,\
 LocalInfoLanguage");
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_LOCALINFOTERMINALRESP, "CSatMessHandler::LocalInfoTerminalResp, LocalInfoLanguage" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_LOCALINFOTERMINALRESP_TD, "CSatMessHandler::LocalInfoTerminalResp, LocalInfoLanguage" );
 if ( aAdditionalInfo.Length() )
 {
 // create Language TLV
 tlvData.AddTag( KTlvLanguageTag );
 }
 case RSat::KProvideLocalInfoAccTech:
 {
 TFLOGSTRING("TSY: CSatMessHandler::LocalInfoTerminalResp,\
 Access Technology");
-OstTrace0( TRACE_NORMAL, DUP3_CSATMESSHANDLER_LOCALINFOTERMINALRESP, "CSatMessHandler::LocalInfoTerminalResp, Access Technology" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATMESSHANDLER_LOCALINFOTERMINALRESP_TD, "CSatMessHandler::LocalInfoTerminalResp, Access Technology" );
 // Access technology result
 tlvData.AddTag( KTlvAccessTechnologyTag );
 tlvData.AddByte( iCurrentAccTech );
 // CSatMessHandler::InfoSerialNumberReadReq
 // Constructs INFO_SERIAL_NUMBER_READ_REQ ISI message.
 // Called from CTsySatMessaging::ConstructL method.
 // -----------------------------------------------------------------------------
 //
-TInt CSatMessHandler::InfoSerialNumberReadReq
+/*TInt CSatMessHandler::InfoSerialNumberReadReq
 (
 TUint8 aTransId,     // Transactio id
 TUint8 aTarget
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_INFOSERIALNUMBERREADREQ, "CSatMessHandler::InfoSerialNumberReadReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_INFOSERIALNUMBERREADREQ_TD, "CSatMessHandler::InfoSerialNumberReadReq" );
 TFLOGSTRING("TSY:CSatMessHandler::InfoSerialNumberReadReq");
 //set infoSerialNumberReadReq to point to the send buffer
 TIsiSend infoSerialNumberReadReq( iPnSend->SendBufferDes() );
 infoSerialNumberReadReq.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_INFO );
 + INFO_SERIAL_NUMBER_READ_REQ_OFFSET_TARGET, aTarget );
 //send message via Phonet
 return iPnSend->Send( infoSerialNumberReadReq.Complete() );
-}
+}*/
 // -----------------------------------------------------------------------------
 // CSatMessHandler::InfoSerialNumberReadResp
 // Breaks a INFO_SERIAL_NUMBER_READ_RESP ISI-message.
 // -----------------------------------------------------------------------------
 //
-void CSatMessHandler::InfoSerialNumberReadResp
+/*void CSatMessHandler::InfoSerialNumberReadResp
 (
 const TIsiReceiveC& aIsiMessage    // received ISI-message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_INFOSERIALNUMBERREADRESP, "CSatMessHandler::InfoSerialNumberReadResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_INFOSERIALNUMBERREADRESP_TD, "CSatMessHandler::InfoSerialNumberReadResp" );
 TFLOGSTRING("TSY:CSatMessHandler::InfoSerialNumberReadResp");
 TUint sbStartOffset( 0 );
 //check if INFO_SB_SN_IMEI_PLAIN sub block is present
 aIsiMessage.Get8bit( sbStartOffset +
 INFO_SB_SN_IMEI_PLAIN_OFFSET_STRLEN ) - 1 ) );
 //Set the flag to inform that needed data has been received
 iImeiAvailable = ETrue;
 TFLOGSTRING("TSY: SAT, Imei received.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_INFOSERIALNUMBERREADRESP, "SAT, Imei received." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_INFOSERIALNUMBERREADRESP_TD, "SAT, Imei received." );
 }
 //check if INFO_SB_SN_IMEI_SV_TO_NET sub block is present
 else if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_INFO_SERIAL_NUMBER_READ_RESP,
 INFO_SB_SN_IMEI_SV_TO_NET, EIsiSubBlockTypeId8Len8,
 sbStartOffset + INFO_SB_SN_IMEI_SV_TO_NET_OFFSET_IMEISVU8,
 aIsiMessage.Get8bit( sbStartOffset +
 INFO_SB_SN_IMEI_SV_TO_NET_OFFSET_STRLEN ) ) );
 iImeiSvAvailable = ETrue;
 TFLOGSTRING("TSY: CSatMessHandler::InfoSerialNumberReadResp IMEISV received");
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_INFOSERIALNUMBERREADRESP, "CSatMessHandler::InfoSerialNumberReadResp IMEISV received" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_INFOSERIALNUMBERREADRESP_TD, "CSatMessHandler::InfoSerialNumberReadResp IMEISV received" );
 }
-}
+}*/
 // -----------------------------------------------------------------------------
 // CSatMessHandler::NetNeighbourCellsReq
 // Constructs NET_NEIGHBOUR_CELLS_REQ ISI message.
 // -----------------------------------------------------------------------------
 (
 TUint8 aTransId,        // Transaction Id
 TUint8 aCellInfoType    // Cell info type
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETNEIGHBOURCELLSREQ, "CSatMessHandler::NetNeighbourCellsReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETNEIGHBOURCELLSREQ_TD, "CSatMessHandler::NetNeighbourCellsReq" );
 TFLOGSTRING("TSY:CSatMessHandler::NetNeighbourCellsReq");
 TBuf8<1> data;
 data.Append( aCellInfoType );
 void CSatMessHandler::NetNeighbourCellResp
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETNEIGHBOURCELLRESP, "CSatMessHandler::NetNeighbourCellResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETNEIGHBOURCELLRESP_TD, "CSatMessHandler::NetNeighbourCellResp" );
 TFLOGSTRING("TSY:CSatMessHandler::NetNeighbourCellResp");
 TUint8 result( RSat::KSuccess );
 if ( iTsySatMessaging->GetNotifyLocalInfo()->LocalInfoStatus() )
 TUint8 aTransId,
 const TDesC8& aMsg
 )
 {
 TFLOGSTRING("TSY:CSatMessHandler::CallModemResourceReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CALLMODEMRESOURCEREQ, "TSY:CSatMessHandler::CallModemResourceReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CALLMODEMRESOURCEREQ_TD, "TSY:CSatMessHandler::CallModemResourceReq" );
 return iPnSend->Send( PN_MODEM_CALL, aTransId, CALL_MODEM_RESOURCE_REQ, aMsg );
 }
 // -----------------------------------------------------------------------------
 TInt CSatMessHandler::CallModemResourceConfReq(
 TUint16 aResourceId,
 TUint16 aResourceIdMask )
 {
 TFLOGSTRING("TSY:CSatMessHandler::CallModemResourceConfReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CALLMODEMRESOURCECONFREQ, "TSY:CSatMessHandler::CallModemResourceConfReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CALLMODEMRESOURCECONFREQ_TD, "TSY:CSatMessHandler::CallModemResourceConfReq" );
 TBuf8< SIZE_CALL_MODEM_RESOURCE_CONF_REQ +
 SIZE_CALL_MODEM_SB_RESOURCE_CONF> msg;
 // CALL_MODEM_RES_CONF_OPERATION
 // -----------------------------------------------------------------------------
 //
 TInt CSatMessHandler::SsResourceConfReq()
 {
 TFLOGSTRING("TSY:CSatMessHandler::SsResourceConfReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SSRESOURCECONFREQ, "TSY:CSatMessHandler::SsResourceConfReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SSRESOURCECONFREQ_TD, "TSY:CSatMessHandler::SsResourceConfReq" );
 TBuf8< SIZE_SS_RESOURCE_CONF_REQ  +
 SIZE_SS_SB_RESOURCE_CONF > msg;
 // SS_RESOURCE_CONF_OPERATION
 TUint8 aTransId,
 const TDesC8& aMsg
 )
 {
 TFLOGSTRING("TSY:CSatMessHandler::SsResourceControlReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SSRESOURCECONTROLREQ, "TSY:CSatMessHandler::SsResourceControlReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SSRESOURCECONTROLREQ_TD, "TSY:CSatMessHandler::SsResourceControlReq" );
 return iPnSend->Send(
 PN_SS,
 aTransId,
 SS_RESOURCE_CONTROL_REQ,
 // -----------------------------------------------------------------------------
 //
 TInt CSatMessHandler::GpdsResourceConfReq()
 {
 TFLOGSTRING("TSY:CSatMessHandler::GpdsResourceConfReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GPDSRESOURCECONFREQ, "TSY:CSatMessHandler::GpdsResourceConfReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GPDSRESOURCECONFREQ_TD, "TSY:CSatMessHandler::GpdsResourceConfReq" );
 TBuf8< SIZE_GPDS_RESOURCE_CONF_REQ  +
 SIZE_GPDS_RESOURCE_CONF > msg;
 // SS_RESOURCE_CONF_OPERATION
 TUint8 aTransId,
 const TDesC8& aMsg
 )
 {
 TFLOGSTRING("TSY:CSatMessHandler::GpdsResourceControlReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GPDSRESOURCECONTROLREQ, "CSatMessHandler::GpdsResourceControlReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GPDSRESOURCECONTROLREQ_TD, "CSatMessHandler::GpdsResourceControlReq" );
 return iPnSend->Send(
 PN_GPDS,
 aTransId,
 GPDS_RESOURCE_CONTROL_REQ,
 // Set Polling Interval, sending a request to sim server
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::SetPollingInterval( TUint8 aTraId, TUint8 aValue )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETPOLLINGINTERVAL, "CSatMessHandler::SetPollingInterval" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETPOLLINGINTERVAL_TD, "CSatMessHandler::SetPollingInterval" );
 TFLOGSTRING("TSY:CSatMessHandler::SetPollingInterval");
 iPollingInterval = aValue;
 TIsiSend isiMsg( iPnSend->SendBufferDes() );
 TUint8 aTimerValue[3],        // Timer Value
 TUint8 aTimerId,              // Timer Identifier
 TUint8 aAdditionalInfo       // Additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_TIMERMGMTTERMINALRESP, "CSatMessHandler::TimerMgmtTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_TIMERMGMTTERMINALRESP_TD, "CSatMessHandler::TimerMgmtTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::TimerMgmtTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 tlvSpecificData.AddByte( aAdditionalInfo );
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::TimerMgmtTerminalResp, Unknown result.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_TIMERMGMTTERMINALRESP, "CSatMessHandler::TimerMgmtTerminalResp, Unknown result." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_TIMERMGMTTERMINALRESP_TD, "CSatMessHandler::TimerMgmtTerminalResp, Unknown result." );
 }
 return UiccCatReqTerminalResponse(
 aCommandDetails,
 tlvSpecificData.GetDataWithoutTopLevelTag(),
 TUint8 aTransId,        // Transaction id
 TUint8 aTimerId,        // Timer Identifier
 TUint8 aTimerValue[3]   // Timer Value
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_TIMEREXPIRATIONIND, "CSatMessHandler::TimerExpirationInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_TIMEREXPIRATIONIND_TD, "CSatMessHandler::TimerExpirationInd" );
 TFLOGSTRING("TSY:CSatMessHandler::TimerExpirationInd");
 TTlv data;
 data.Begin( KBerTlvTimerExpirationTag );
 return UiccCatReqEnvelope( aTransId, data.End() );
 }
 // -----------------------------------------------------------------------------
-// CSatMessHandler::RefreshResult
+// CSatMessHandler::RefreshResultL
 // Method to analyze refresh result from SIM Server.
 // Called by CSatMessHandler::SimAtkResp.
 // -----------------------------------------------------------------------------
 //
-void CSatMessHandler::RefreshResult( TUint8 aStatus ) // UICC server status
+void CSatMessHandler::RefreshResultL( TUint8 aStatus ) // UICC server status
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_REFRESHRESULT, "CSatMessHandler::RefreshResult" );
+OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_REFRESHRESULTL_TD, "CSatMessHandler::RefreshResultL" );
-TFLOGSTRING("TSY:CSatMessHandler::RefreshResult");
+TFLOGSTRING("TSY:CSatMessHandler::RefreshResultL");
 TUint8 result( RSat::KSuccess );
 TUint8 additionalInfo( 0 );
 TInt ret( KErrNone );
 switch ( aStatus )
 {
 case UICC_STATUS_OK:
 {
 // Refresh is done!
-TFLOGSTRING("TSY: CSatMessHandler::RefreshResult, ISA has performed refresh successfully ");
+TFLOGSTRING("TSY: CSatMessHandler::RefreshResultL, ISA has performed refresh successfully ");
-TFLOGSTRING("TSY: CSatMessHandler::RefreshResult, Inform S60 to re-read SIM data");
+TFLOGSTRING("TSY: CSatMessHandler::RefreshResultL, Inform S60 to re-read SIM data");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_REFRESHRESULT, "CSatMessHandler::RefreshResult, ISA has performed refresh successfully " );
+OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_REFRESHRESULTL_TD, "CSatMessHandler::RefreshResultL, ISA has performed refresh successfully " );
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_REFRESHRESULT, "CSatMessHandler::RefreshResult, Inform S60 to re-read SIM data" );
+OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_REFRESHRESULTL_TD, "CSatMessHandler::RefreshResultL, Inform S60 to re-read SIM data" );
 // Read service table
 if ( CSatNotifyRefresh::KCacheEFSST &
 iTsySatMessaging->GetNotifyRefresh()->CachedFiles() )
 {
+TInt ret( KErrNone );
 // Re-read EF-UST
-// Call control in USSD is supported only in SIM, byte 6
 if ( UICC_CARD_TYPE_ICC == iCardType )
 {
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte6, 5 );
+// Call control in USSD is supported only in SIM, from byte 10
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte11, 10 );
+User::LeaveIfError( ret );
+// SMS-PP DD and Call Control from byte 7
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte7, 6 );
+User::LeaveIfError( ret );
 }
+else if( UICC_CARD_TYPE_UICC == iCardType )
-// Call control, byte 4 from service table
+{
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
+// Call control, MO-SMS Control and SMS PP Datadownload, from byte 4
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
+User::LeaveIfError( ret );
+}
 #ifdef INFO_PP_ATK_MO_SM_CONTROL
 // Check MO SMS control is supported by product profile
-// USIM: byte 4, SIM: byte 5
+// USIM: byte 4, SIM: byte 10
 TUint8 serviceTableTrIdMoSms( KUiccTrIdServiceTableByte4 );
 TUint8 serviceTableOffsetMoSms( 3 );
 if ( UICC_CARD_TYPE_ICC == iCardType )
 {
 // Transaction ID and byte offset for SIM
-serviceTableTrIdMoSms = KUiccTrIdServiceTableByte5;
+serviceTableTrIdMoSms = KUiccTrIdServiceTableByte10;
-serviceTableOffsetMoSms = 4;
+serviceTableOffsetMoSms = 9;
 }
 if ( iMoSmsSupportedInPp )
 {
 // ...and by SIM service table
-UiccReadServiceTableReq(
+ret = UiccReadServiceTableReq(
 serviceTableTrIdMoSms,
 serviceTableOffsetMoSms );
+User::LeaveIfError( ret );
 }
 #else
 // If flag not defined, check feature availability only
 // from USIM
-UiccReadServiceTableReq(
+ret = UiccReadServiceTableReq(
 serviceTableTrIdMoSms,
 serviceTableOffsetMoSms );
+User::LeaveIfError( ret );
 #endif // INFO_PP_ATK_MO_SM_CONTROL
 }
 break;
 }
 default:
 {
-TFLOGSTRING2("TSY: CSatMessHandler::RefreshResult, refresh failed, UICC STATUS: 0x%x", aStatus );
+TFLOGSTRING2("TSY: CSatMessHandler::RefreshResultL, refresh failed, UICC STATUS: 0x%x", aStatus );
-OstTraceExt1( TRACE_NORMAL, DUP4_CSATMESSHANDLER_REFRESHRESULT, "CSatMessHandler::RefreshResult, refresh failed, UICC STATUS: 0x%hhx", aStatus );
+OstTraceExt1( TRACE_NORMAL, DUP4_CSATMESSHANDLER_REFRESHRESULTL_TD, "CSatMessHandler::RefreshResultL, refresh failed, UICC STATUS: 0x%hhx", aStatus );
 result = RSat::KMeUnableToProcessCmd;
 additionalInfo = RSat::KNoSpecificMeProblem;
 ret = KErrGeneral;
 break;
 }
 (
 TUint8 aTransId,
 TDesC8& aData
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDSMSREPORTREQ, "CSatMessHandler::SendSmsReportReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDSMSREPORTREQ_TD, "CSatMessHandler::SendSmsReportReq" );
 TFLOGSTRING("CSatMessHandler::SendSmsReportReq");
 iPnSend->Send( PN_SMS, aTransId, SMS_RECEIVED_MSG_REPORT_REQ, aData );
 }
 TUint8 aTransId,
 TUint8 aMsgId,
 TDesC8& aData
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SMSRESOURCECONFREQ, "CSatMessHandler::SmsResourceConfReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SMSRESOURCECONFREQ_TD, "CSatMessHandler::SmsResourceConfReq" );
 TFLOGSTRING("CSatMessHandler::SmsResourceConfReq");
 iPnSend->Send( PN_SMS, aTransId, aMsgId, aData );
 }
 TUint8 aStatus,
 TUint8 aTransId,
 TUint8 aInterval
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETPOLLINGRESULT, "CSatMessHandler::SetPollingResult" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETPOLLINGRESULT_TD, "CSatMessHandler::SetPollingResult" );
 TFLOGSTRING("TSY:CSatMessHandler::SetPollingResult ");
 if ( UICC_STATUS_OK == aStatus )
 {
 // The response can be from a PollInterval or a PollingOff command
 if ( iPollingOff )
 {
 TFLOGSTRING("TSY:CSatMessHandler::SetPollingResult, iPollingOff = ETrue");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_SETPOLLINGRESULT, "CSatMessHandler::SetPollingResult, iPollingOff = ETrue" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_SETPOLLINGRESULT_TD, "CSatMessHandler::SetPollingResult, iPollingOff = ETrue" );
 PollingOffTerminalResp(
 aTransId,
 iTsySatMessaging->GetNotifyPollingOff()->GetCmdDetails(),
 RSat::KSuccess,
 RSat::KNoAdditionalInfo );
 }
 else
 {
 TFLOGSTRING("TSY:CSatMessHandler::SetPollingResult, iPollingOff = EFalse");
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_SETPOLLINGRESULT, "CSatMessHandler::SetPollingResult, iPollingOff = EFalse" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_SETPOLLINGRESULT_TD, "CSatMessHandler::SetPollingResult, iPollingOff = EFalse" );
 PollIntervalTerminalResp(
 aTransId,
 iTsySatMessaging->GetNotifyPollInterval()->GetCmdDetails(),
 RSat::KSuccess,
 RSat::KNoAdditionalInfo,
 TInt CSatMessHandler::CheckProactiveCommand
 (
 const TIsiReceiveC& aIsiMessage // received isi message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CHECKPROACTIVECOMMAND, "CSatMessHandler::CheckProactiveCommand" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CHECKPROACTIVECOMMAND_TD, "CSatMessHandler::CheckProactiveCommand" );
 TFLOGSTRING("TSY:CSatMessHandler::CheckProactiveCommand");
 TTlv data;
 // Get ber tlv
 CBerTlv berTlv;
 ret = KErrCorrupt;
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::CheckProactiveCommand. Proactive command Ok.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_CHECKPROACTIVECOMMAND, "CSatMessHandler::CheckProactiveCommand Proactive command Ok." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_CHECKPROACTIVECOMMAND_TD, "CSatMessHandler::CheckProactiveCommand Proactive command Ok." );
 }
 if ( KErrCorrupt == ret )
 {
 if ( !berTlv.TlvByTagValue( &commandDetails,
 TUint8 aTransId,            // Transaction id
 TDes8& aCommandDetails,     // Command details
 TUint8 aGeneralResult       // General result
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_MORETIMETERMINALRESP, "CSatMessHandler::MoreTimeTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_MORETIMETERMINALRESP_TD, "CSatMessHandler::MoreTimeTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::MoreTimeTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 (
 TUint8 aTransId,        // Transaction Id
 TUint8 aRoutingCommand  // Routing command
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SMSCBROUTINGREQ, "CSatMessHandler::SmsCbRoutingReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SMSCBROUTINGREQ_TD, "CSatMessHandler::SmsCbRoutingReq" );
 TFLOGSTRING("TSY:CSatMessHandler::SmsRoutingReq");
 TInt ret( KErrNone );
+iCbRoutingReqTraId = TInt( aTransId );
-// Routing is ongoing
-iSmsCbRoutingComplete = EFalse;
+// Routing is ongoing
+iSmsCbRoutingComplete = EFalse;
-// TBuf8<SIZE_SMS_CB_ROUTING_REQ> because we are sending [U]SIM EF CBMID Message
-// Subscription;
+// TBuf8<SIZE_SMS_CB_ROUTING_REQ> because we are sending [U]SIM EF CBMID Message
-TBuf8<SIZE_SMS_CB_ROUTING_REQ> data;
+// Subscription;
+TBuf8<SIZE_SMS_CB_ROUTING_REQ> data;
-// Append Routing command
-data.Append( aRoutingCommand );
+// Append Routing command
-// Append Subscription number
+data.Append( aRoutingCommand );
-data.Append( SMS_NEW_SUBSCRIPTION );
+// Append Subscription number
-// append Subscription type
+data.Append( SMS_NEW_SUBSCRIPTION );
-data.Append( SMS_TYPE_SIM );
+// append Subscription type
-// Append Filler bytes
+data.Append( SMS_TYPE_SIM );
-data.AppendFill( KPadding, 2 );
+// Append Filler bytes
-// Append no of Subblocks
+data.AppendFill( KPadding, 2 );
-data.Append( 0 );
+// Append no of Subblocks
+data.Append( 0 );
-// Send Subscription request
-ret = iPnSend->Send( PN_SMS, aTransId, SMS_CB_ROUTING_REQ,
+// Send Subscription request
-data );
+ret = iPnSend->Send( PN_SMS, aTransId, SMS_CB_ROUTING_REQ,
+data );
 return ret;
 }
 // -----------------------------------------------------------------------------
 void CSatMessHandler::SmsCbRoutingResp
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SMSCBROUTINGRESP, "CSatMessHandler::SmsCbRoutingResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SMSCBROUTINGRESP_TD, "CSatMessHandler::SmsCbRoutingResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SmsCbRoutingResp");
-TUint8 cause( aIsiMessage.Get8bit(
+if ( iCbRoutingReqTraId == aIsiMessage.Get8bit(
-ISI_HEADER_SIZE + SMS_CB_ROUTING_RESP_OFFSET_SMSCAUSE ) );
+ISI_HEADER_OFFSET_TRANSID ) )
+{
-switch ( cause )
+TUint8 cause( aIsiMessage.Get8bit(
-{
+ISI_HEADER_SIZE + SMS_CB_ROUTING_RESP_OFFSET_SMSCAUSE ) );
-case SMS_ERR_CS_INACTIVE:
+iCbRoutingReqTraId = KNoTransactionOngoing;
-case SMS_ERR_SUBJECT_COUNT_OVERFLOW:
-case SMS_ERR_DCS_COUNT_OVERFLOW:
+switch ( cause )
 {
-TFLOGSTRING2("TSY:CSatMessHandler::SmsCbRoutingResp \
+case SMS_ERR_CS_INACTIVE:
-Routing req failed on temporary problem: %d", cause );
+case SMS_ERR_SUBJECT_COUNT_OVERFLOW:
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_SMSCBROUTINGRESP, "CSatMessHandler::SmsCbRoutingResp Routing req failed on temporary problem: %hhu", cause );
+case SMS_ERR_DCS_COUNT_OVERFLOW:
-iSmsCbRoutingComplete = EFalse;
+{
-break;
+TFLOGSTRING2("TSY:CSatMessHandler::SmsCbRoutingResp \
-}
+Routing req failed on temporary problem: %d", cause );
-case SMS_OK:
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_SMSCBROUTINGRESP_TD, "CSatMessHandler::SmsCbRoutingResp Routing req failed on temporary problem: %hhu", cause );
-case SMS_ERR_INVALID_SUBSCRIPTION_NR:
+iSmsCbRoutingComplete = EFalse;
-case SMS_ERR_INVALID_PARAMETER:
+break;
-case SMS_ERR_ALL_SUBSCRIPTIONS_ALLOCATED:
+}
-default:
+case SMS_OK:
-{
+case SMS_ERR_INVALID_SUBSCRIPTION_NR:
-// Routing req was either completed successfully, or permanent
+case SMS_ERR_INVALID_PARAMETER:
-// problem occured. In both cases, no need to retry.
+case SMS_ERR_ALL_SUBSCRIPTIONS_ALLOCATED:
-iSmsCbRoutingComplete = ETrue;
+default:
-break;
+{
+// Routing req was either completed successfully, or permanent
+// problem occured. In both cases, no need to retry.
+iSmsCbRoutingComplete = ETrue;
+break;
+}
 }
 }
 }
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY:CSatMoSmsCtrl::SmsResourceConfIndReceived: Response for Resource confoguration Indication, Receive Indication from SMS server");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMOSMSCTRL_SMSRESOURCECONFINDRECEIVED, "CSatMoSmsCtrl::SmsResourceRespReceived: Response for Resource Configuration Ind, Receive indication from SMS server" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMOSMSCTRL_SMSRESOURCECONFINDRECEIVED_TD, "CSatMoSmsCtrl::SmsResourceRespReceived: Response for Resource Configuration Ind, Receive indication from SMS server" );
 // To check The receive indication is for startup or reconfiguration
 if ( SMS_RES_CONF_STARTUP == aIsiMessage.Get8bit( ISI_HEADER_SIZE
 + SMS_RESOURCE_CONF_IND_OFFSET_CONFSTATUS ) )
 {
 // USIM: Read MO-SMS control from byte 4
 UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
 }
 else if ( UICC_CARD_TYPE_ICC == iCardType )
 {
-// SIM: Read MO-SMS control from byte 5
+// SIM: Read MO-SMS control from byte 10
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte5, 4 );
+UiccReadServiceTableReq( KUiccTrIdServiceTableByte10, 9 );
 }
 }
 }
 }
 }
 TInt CSatMessHandler::NetCellInfoGetReq
 (
 TUint8 aTransId
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETCELLINFOGETREQ, "CSatMessHandler::NetCellInfoGetReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETCELLINFOGETREQ_TD, "CSatMessHandler::NetCellInfoGetReq" );
 TFLOGSTRING("TSY:CSatMessHandler::NetCellInfoGetReq");
 TBuf8<1> noData;
 return iPnSend->Send(
 PN_MODEM_NETWORK,
 void CSatMessHandler::NetCellInfoGetResp
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETCELLINFOGETRESP, "CSatMessHandler::NetCellInfoGetResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETCELLINFOGETRESP_TD, "CSatMessHandler::NetCellInfoGetResp" );
 TFLOGSTRING("TSY: CSatMessHandler::NetCellInfoGetResp");
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_CELL_INFO_GET_RESP_OFFSET_SUCCESSCODE ) );
 }
 default:
 {
 // Default result value already set
 TFLOGSTRING2("TSY: CSatMessHandler::NetCellInfoGetResp - Unexpected iRegStatus: %d", iLocInfo.iRegStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_NETCELLINFOGETRESP, "CSatMessHandler::NetCellInfoGetResp Unexpected iRegStatus: %d", iLocInfo.iRegStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_NETCELLINFOGETRESP_TD, "CSatMessHandler::NetCellInfoGetResp Unexpected iRegStatus: %d", iLocInfo.iRegStatus );
 additionalInfo.Append( RSat::KNoSpecificMeProblem );
 break;
 }
 }
 (
 TUint8 aTransId,          // Transaction Id
 TUint8 aOperation         // Gss operation
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GSSCSSERVICEREQ, "CSatMessHandler::GssCsServiceReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GSSCSSERVICEREQ_TD, "CSatMessHandler::GssCsServiceReq" );
 TFLOGSTRING("TSY: CSatMessHandler::GssCsServiceReq ");
 TBuf8<2> data;
 data.Append( aOperation );
 data.Append( 0x00 ); // number of subblocks
 void CSatMessHandler::GssCsServiceResp
 (
 const TIsiReceiveC& aIsiMessage // Received isi messge
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GSSCSSERVICERESP, "CSatMessHandler::GssCsServiceResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GSSCSSERVICERESP_TD, "CSatMessHandler::GssCsServiceResp" );
 TFLOGSTRING("CSatMessHandler::GssCsServiceResp ");
 if ( iTsySatMessaging->GetNotifyLocalInfo()->LocalInfoStatus() )
 {
 TUint8 generalResult ( RSat::KSuccess );
 // Store Timing Advance Status
 iTaStatus = aIsiMessage.Get8bit(
 sbOffset + GSS_ATK_TIMING_ADVANCE_OFFSET_TASTATUS );
 TFLOGSTRING2("TSY: CSatMessHandler::GssCsServiceResp iTaStatus=%d", iTaStatus);
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_GSSCSSERVICERESP, "CSatMessHandler::GssCsServiceResp iTaStatus: %hhu", iTaStatus );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_GSSCSSERVICERESP_TD, "CSatMessHandler::GssCsServiceResp iTaStatus: %hhu", iTaStatus );
 // Store timing advance
 iTimingAdvance = aIsiMessage.Get8bit(
 sbOffset + GSS_ATK_TIMING_ADVANCE_OFFSET_TIMINGADVANCE );
 TFLOGSTRING2("TSY: CSatMessHandler::GssCsServiceResp \
 iTimingAdvance=%d", iTimingAdvance);
-OstTraceExt1( TRACE_NORMAL, DUP2_CSATMESSHANDLER_GSSCSSERVICERESP, "CSatMessHandler::GssCsServiceResp iTimingAdvance: %hhu", iTimingAdvance );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_GSSCSSERVICERESP_TD, "CSatMessHandler::GssCsServiceResp iTimingAdvance: %hhu", iTimingAdvance );
 if ( GSS_TIMING_ADVANCE_NOT_AVAILABLE == iTimingAdvance )
 {
 generalResult = RSat::KMeUnableToProcessCmd;
 }
 void CSatMessHandler::GssCsServiceFailResp
 (
 const TIsiReceiveC& aIsiMessage // Received isi messge
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GSSCSSERVICEFAILRESP, "CSatMessHandler::GssCsServiceFailResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GSSCSSERVICEFAILRESP_TD, "CSatMessHandler::GssCsServiceFailResp" );
 TFLOGSTRING("CSatMessHandler::GssCsServiceFailResp ");
 if ( iTsySatMessaging->GetNotifyLocalInfo()->LocalInfoStatus() )
 {
 if ( GSS_ATK_TIMING_ADVANCE_GET == aIsiMessage.Get8bit(
 TDes8& aCommandDetails,     // Comamnd number
 TUint8 aGeneralResult,      // General result
 TUint8 aAdditionalInfo      // additional info
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_LANGUAGENOTIFICATIONTERMINALRESP, "CSatMessHandler::LanguageNotificationTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_LANGUAGENOTIFICATIONTERMINALRESP_TD, "CSatMessHandler::LanguageNotificationTerminalResp" );
 TFLOGSTRING("TSY:CSatMessHandler::LanguageNotificationTerminalResp");
 TTlv tlvSpecificData;
 // Create general result TLV here
 tlvSpecificData.AddTag( KTlvResultTag );
 void CSatMessHandler::NetTimeInd
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETTIMEIND, "CSatMessHandler::NetTimeInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETTIMEIND_TD, "CSatMessHandler::NetTimeInd" );
 TFLOGSTRING("TSY: CSatMessHandler::NetTimeInd");
 // NET_TIME_INFO is mandatory sub block
 // SubBlock offset
 // Get timezone
 // If the time zone is invalid or time zone is unknown, all bits are
 // set to 1 (including B6).
 iTimeZone = aIsiMessage.Get8bit( sbOffset + NET_TIME_INFO_OFFSET_TIMEZONE );
 TFLOGSTRING2("TSY: CSatMessHandler::NetTimeInd, Time zone: 0x%x", iTimeZone );
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_NETTIMEIND, "CSatMessHandler::NetTimeInd Time zone: %hhu", iTimeZone );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_NETTIMEIND_TD, "CSatMessHandler::NetTimeInd Time zone: %hhu", iTimeZone );
 }
 }
 // -----------------------------------------------------------------------------
 // CSatMessHandler::OpenChannelTerminalResp
 TUint8 aBearerType,         // Bearer type
 TDesC8& aBearer,            // Bearer
 TUint16 aBufferSize         // Buffer size
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_OPENCHANNELTERMINALRESP, "CSatMessHandler::OpenChannelTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_OPENCHANNELTERMINALRESP_TD, "CSatMessHandler::OpenChannelTerminalResp" );
 TFLOGSTRING("CSatMessHandler::OpenChannelTerminalResp");
 // Create and append response data
 TTlv tlvSpecificData;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::OpenChannelTerminalResp, General result did not match.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_OPENCHANNELTERMINALRESP, "CSatMessHandler::OpenChannelTerminalResp, General result did not match." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_OPENCHANNELTERMINALRESP_TD, "CSatMessHandler::OpenChannelTerminalResp, General result did not match." );
 }
 // For any result:
 // Append Bearer Description data
 TDes8 &aCommandDetails,
 TUint8 aGeneralResult,
 const TDes8& aAdditionalInfo
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETCHANNELSTATUSTERMINALRESP, "CSatMessHandler::GetChannelStatusTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETCHANNELSTATUSTERMINALRESP_TD, "CSatMessHandler::GetChannelStatusTerminalResp" );
 TFLOGSTRING("CSatMessHandler::GetChannelStatusTerminalResp");
 TTlv tlvSpecificData;
 // Append general result tag
 tlvSpecificData.AddTag( KTlvResultTag );
 // Append general result
 }
 else
 {
 TFLOGSTRING("CSatMessHandler::GetChannelStatusTerminalResp - mandatory channel status missing");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_GETCHANNELSTATUSTERMINALRESP, "CSatMessHandler::GetChannelStatusTerminalResp - mandatory channel status missing" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_GETCHANNELSTATUSTERMINALRESP_TD, "CSatMessHandler::GetChannelStatusTerminalResp - mandatory channel status missing" );
 }
 return UiccCatReqTerminalResponse(
 aCommandDetails,
 tlvSpecificData.GetDataWithoutTopLevelTag(),
 TDes8 &aCommandDetails,
 TUint8 aGeneralResult,
 const TDes8& aAdditionalInfo
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CLOSECHANNELTERMINALRESP, "CSatMessHandler::CloseChannelTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CLOSECHANNELTERMINALRESP_TD, "CSatMessHandler::CloseChannelTerminalResp" );
 TFLOGSTRING("CSatMessHandler::CloseChannelTerminalResp");
 TTlv tlvSpecificData;
 // Append general result tag
 tlvSpecificData.AddTag( KTlvResultTag );
 // Append general result
 TUint8 aGeneralResult,
 const TDes8& aAdditionalInfo,
 TUint8 aChannelDataLength
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDDATATERMINALRESP, "CSatMessHandler::SendDataTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDDATATERMINALRESP_TD, "CSatMessHandler::SendDataTerminalResp" );
 TFLOGSTRING("CSatMessHandler::SendDataTerminalResp");
 TTlv tlvSpecificData;
 // Append general result tag
 tlvSpecificData.AddTag( KTlvResultTag );
 // Append general result
 tlvSpecificData.AddByte( aChannelDataLength );
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::SendDataTerminalResp, General result did not match.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_SENDDATATERMINALRESP, "CSatMessHandler::SendDataTerminalResp, General result did not match." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_SENDDATATERMINALRESP_TD, "CSatMessHandler::SendDataTerminalResp, General result did not match." );
 }
 return UiccCatReqTerminalResponse(
 aCommandDetails,
 tlvSpecificData.GetDataWithoutTopLevelTag(),
 TUint8 aGeneralResult,
 const TDes8& aAdditionalInfo,
 TUint8 aChannelDataLength
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_RECEIVEDATATERMINALRESP, "CSatMessHandler::ReceiveDataTerminalResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_RECEIVEDATATERMINALRESP_TD, "CSatMessHandler::ReceiveDataTerminalResp" );
 TFLOGSTRING("CSatMessHandler::ReceiveDataTerminalResp");
 TTlv tlvSpecificData;
 // Append general result tag
 tlvSpecificData.AddTag( KTlvResultTag );
 // Append general result
 tlvSpecificData.AddByte( aChannelDataLength );
 }
 else
 {
 TFLOGSTRING("TSY: CSatMessHandler::ReceiveDataTerminalResp, General result did not match.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_RECEIVEDATATERMINALRESP, "CSatMessHandler::ReceiveDataTerminalResp, General result did not match." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_RECEIVEDATATERMINALRESP_TD, "CSatMessHandler::ReceiveDataTerminalResp, General result did not match." );
 }
 return UiccCatReqTerminalResponse(
 aCommandDetails,
 tlvSpecificData.GetDataWithoutTopLevelTag(),
 TUint8 aTransId,
 TDesC8& aData,
 TUint8 aReceiverObject
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDSMSRESOURCERESP, "CSatMessHandler::SendSmsResourceResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SENDSMSRESOURCERESP_TD, "CSatMessHandler::SendSmsResourceResp" );
 TFLOGSTRING("TSY:CSatMessHandler::SendSmsResourceResp");
 TIsiSend isimsg( iPnSend->SendBufferDes() );
 isimsg.Set8bit( ISI_HEADER_OFFSET_RECEIVEROBJECT, aReceiverObject );
 isimsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_SMS );
 void CSatMessHandler::SsStatusInd
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SSSTATUSIND, "CSatMessHandler::SsStatusInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SSSTATUSIND_TD, "CSatMessHandler::SsStatusInd" );
 TFLOGSTRING("TSY: CSatMessHandler::SsStatusInd");
 TUint8 ssStatus  = aIsiMessage.Get8bit( ISI_HEADER_SIZE
 + SS_STATUS_IND_OFFSET_SSSTATUSINDICATION );
 TBool CSatMessHandler::AdditionalInfoNeeded
 (
 const TUint8 aGeneralResult
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_ADDITIONALINFONEEDED, "CSatMessHandler::AdditionalInfoNeeded" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_ADDITIONALINFONEEDED_TD, "CSatMessHandler::AdditionalInfoNeeded" );
 // NOTE: This method shall not be used with SendSS proactive command as its
 // additional info handling differs from other commands.
 TBool ret( EFalse );
 void CSatMessHandler::ReceiveMessageL
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_RECEIVEMESSAGEL, "CSatMessHandler::ReceiveMessageL" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_RECEIVEMESSAGEL_TD, "CSatMessHandler::ReceiveMessageL" );
 TFLOGSTRING("TSY: CSatMessHandler::ReceiveMessageL");
 // Get ISI message resource and id
 TInt resource ( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 case PN_SS:
 {
 SsServerMessageReceived( aIsiMessage );
 break;
 }
-case PN_PHONE_INFO:
+/*case PN_PHONE_INFO:
 {
-PhoneInfoMessageReceived( aIsiMessage );
+PhoneInfoMessageReceivedL( aIsiMessage );
 break;
-}
+}*/
 case PN_MODEM_NETWORK:
 {
 NetServerMessageReceived( aIsiMessage );
 break;
 }
 SmsServerMessageReceived( aIsiMessage );
 break;
 }
 case PN_UICC:
 {
-handled = UiccServerMessageReceived( aIsiMessage );
+handled = UiccServerMessageReceivedL( aIsiMessage );
 break;
 }
 default:
 {
 // Do nothing
 (
 const TIsiReceiveC& /*aIsiMessage*/,
 TInt /*aErrorCode*/
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_HANDLEERROR, "CSatMessHandler::HandleError" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_HANDLEERROR_TD, "CSatMessHandler::HandleError" );
 // No implementation
 }
 // -----------------------------------------------------------------------------
 void CSatMessHandler::NetRatInd
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETRATIND, "CSatMessHandler::NetRatInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_NETRATIND_TD, "CSatMessHandler::NetRatInd" );
 TFLOGSTRING("TSY:CSatMessHandler::NetRatInd");
 // Check the presence of subblocks
 if ( 0 != aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_RAT_IND_OFFSET_SUBBLOCKCOUNT ) )
 break;
 }
 }
 }
 TFLOGSTRING2("TSY:CSatMessHandler::NetRatInd - Current Acc Tech: %d",iCurrentAccTech);
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_NETRATIND, "CSatMessHandler::NetRatInd - Current Acc Tech: %hhu", iCurrentAccTech );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_NETRATIND_TD, "CSatMessHandler::NetRatInd - Current Acc Tech: %hhu", iCurrentAccTech );
 }
 }
 // -----------------------------------------------------------------------------
 // Getter for location information structure
 // -----------------------------------------------------------------------------
 //
 const CSatMessHandler::TLocationInfo& CSatMessHandler::LocationInfo()
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_LOCATIONINFO, "CSatMessHandler::LocationInfo" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_LOCATIONINFO_TD, "CSatMessHandler::LocationInfo" );
 // Extended Cell Id is provided only if both USIM and
 // 3G network are present.
 if ( KNetworkModeUtran != iCurrentAccTech
 || UICC_CARD_TYPE_UICC != iCardType )
 {
 return iLocInfo;
 }
 // -----------------------------------------------------------------------------
-// CSatMessHandler::SendPnAtkMessage
-// Sends a PN_ATK message with the given data, sets also possible filler bytes
-// -----------------------------------------------------------------------------
-//
-TInt CSatMessHandler::SendPnAtkMessage
-(
-const TUint8 aReceiverObject,
-const TUint8 aTransactionId,
-const TInt aMessageId,
-const TDesC8& aData
-)
-{
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SENDPNATKMESSAGE, "CSatMessHandler::SendPnAtkMessage" );
-TFLOGSTRING("TSY:CSatMessHandler::SendPnAtkMessage");
-TBuf8<KLengthTwoBytes> data;
-data.Append( aTransactionId );
-data.Append( aMessageId );
-// Create send buffer (sets the msg length to NULL)
-TIsiSend isimsg( iPnSend->SendBufferDes() );
-// Set the receiver object and resource ID
-isimsg.Set8bit( ISI_HEADER_OFFSET_RECEIVEROBJECT, aReceiverObject );
-isimsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_ATK );
-// Set Transaction ID and Msg ID at the end of the message buffer
-isimsg.CopyData( ISI_HEADER_SIZE, data );
-// Copy the message data at the end of the message buffer
-isimsg.CopyData( ( ISI_HEADER_SIZE + KLengthTwoBytes ), aData );
-// Add padding(s)
-while ( iPnSend->SendBufferDes().Length() % 4 )
-{
-iPnSend->SendBufferDes().Append( 0x00 );
-}
-// Send message
-return iPnSend->Send( isimsg.Complete() );
-}
-// -----------------------------------------------------------------------------
 // CSatMessHandler::UiccApplCmdResp
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::UiccApplCmdResp( const TIsiReceiveC& aIsiMessage )
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccApplCmdResp");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCAPPLCMDRESP, "CSatMessHandler::UiccApplCmdResp" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCAPPLCMDRESP_TD, "CSatMessHandler::UiccApplCmdResp" );
 TInt error( KErrNone );
 // Get transaction ID, status and service type
 TUint8 trId( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + UICC_APPL_CMD_RESP_OFFSET_TRANSID ) );
 fileDataLength ) );
 }
 else // Subblock is mandatory
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccApplCmdResp - Mandatory subblock UICC_SB_FILE_DATA not found");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCAPPLCMDRESP, "CSatMessHandler::UiccApplCmdResp - Mandatory subblock UICC_SB_FILE_DATA not found" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCAPPLCMDRESP_TD, "CSatMessHandler::UiccApplCmdResp - Mandatory subblock UICC_SB_FILE_DATA not found" );
 error = KErrNotFound;
 }
 switch( trId )
 {
 // Call control, SMS PP DD, USIM MO-SMS control
 case KUiccTrIdServiceTableByte4:
 {
 if ( KErrNone == error )
 {
-TUint8 usedBitMaskSmsPpDd( KSmsPpDdBitMaskUsim );
+// MO SMS control status, only in case of USIM
-if ( UICC_CARD_TYPE_ICC == iCardType )
+SimMoSmsControlAvail(
+fileData[0] & KMoSmsControlBitMaskUsim );
+iTsySatMessaging->GetDataDownload()->SmsPpDlSupported(
+fileData[0] & KSmsPpDdBitMaskUsim );
+}
+break;
+}
+// MO SMS control ( this transaction ID is used for SIM only )
+case KUiccTrIdServiceTableByte10:
+{
+if ( KErrNone == error )
+{
+// MO SMS control status, only in case of USIM
+SimMoSmsControlAvail(
+KMoSmsControlBitMaskSim == ( fileData[0] & KMoSmsControlBitMaskSim ) );
+}
+break;
+}
+// USSD in Call Control ( this transaction ID is used for SIM only )
+case KUiccTrIdServiceTableByte11:
+{
+iTsySatMessaging->SetStatusOfUssdSupport(
+KMoUssdCallControlBitMaskSim == ( fileData[0] & KMoUssdCallControlBitMaskSim ) );
+break;
+}
+// SMS PP Datadownload ( this transaction ID is used for SIM only )
+case KUiccTrIdServiceTableByte7:
+{
+if ( UICC_CARD_TYPE_UICC == iCardType )
+{
+TBool ppDdSupported( EFalse );
+if( KSmsPpDdBitMaskSim == ( fileData[0] & KSmsPpDdBitMaskSim ) )
 {
-usedBitMaskSmsPpDd = KSmsPpDdBitMaskSim;
+ppDdSupported = ETrue;
 }
-else
+iTsySatMessaging->GetDataDownload()->SmsPpDlSupported( ppDdSupported );
-{
+}
-// MO SMS control status, only in case of USIM
-SimMoSmsControlAvail(
-fileData[0] & KMoSmsControlBitMaskUsim );
-}
-// Get status of SMS PP DD and report to DataDownload
-iTsySatMessaging->GetDataDownload()->SmsPpDlSupported(
-( fileData[0] & usedBitMaskSmsPpDd ) ? ETrue : EFalse );
-}
-break;
-}
-// MO SMS control ( this transaction ID is used for SIM only )
-case KUiccTrIdServiceTableByte5:
-{
-if ( KErrNone == error )
-{
-SimMoSmsControlAvail( fileData[0] & KMoSmsControlBitMaskSim );
-}
-break;
-}
-// USSD in Call Control ( this transaction ID is used for SIM only )
-case KUiccTrIdServiceTableByte6:
-{
-iTsySatMessaging->SetStatusOfUssdSupport(
-fileData[0] & KMoUssdCallControlBitMaskSim );
 break;
 }
 // SAT icon
 case KUiccTrIdReadSatIcon:
 {
 } // End of switch( trId )
 }
 // -----------------------------------------------------------------------------
-// CSatMessHandler::UiccCatInd
+// CSatMessHandler::UiccCatIndL
 // Breaks UICC_CAT_IND ISI-message.
 // -----------------------------------------------------------------------------
 //
-void CSatMessHandler::UiccCatInd
+void CSatMessHandler::UiccCatIndL
 (
 const TIsiReceiveC& aIsiMessage // Received ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATIND, "CSatMessHandler::UiccCatInd" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATINDL_TD, "CSatMessHandler::UiccCatIndL" );
-TFLOGSTRING("TSY: CSatMessHandler::UiccCatInd");
+TFLOGSTRING("TSY: CSatMessHandler::UiccCatIndL");
 // UICC status
 TUint8 serviceType( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + UICC_CAT_IND_OFFSET_SERVICETYPE ) );
 {
 iTsySatMessaging->PCmdReceivedL( aIsiMessage );
 }
 else
 {
-TFLOGSTRING("TSY: Received SAT message was not valid!");
+TFLOGSTRING("TSY: CSatMessHandler::UiccCatIndL: Received SAT message was not valid!");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCCATIND, "CSatMessHandler::UiccCatInd. Received SAT message was not valid!" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCCATINDL_TD, "CSatMessHandler::UiccCatIndL. Received SAT message was not valid!" );
 }
 }
 }
 // -----------------------------------------------------------------------------
 // CSatMessHandler::InfoPpReadReq
 // Construct a INFO_PP_READ_REQ ISI message
 // -----------------------------------------------------------------------------
 //
-TInt CSatMessHandler::InfoPpReadReq
+/*TInt CSatMessHandler::InfoPpReadReq
 (
 const TUint8 aReqType // request type
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_INFOPPREADREQ, "CSatMessHandler::InfoPpReadReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_INFOPPREADREQ_TD, "CSatMessHandler::InfoPpReadReq" );
 TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadReq" );
 // Construct INFO_PP_READ_REQ message (INFO_BATCH_TYPE +
 // sub block count + INFO_SB_PP sub block)
 TBuf8<2 + SIZE_INFO_SB_PP> infoPpReadReq;
 return iPnSend->Send(
 PN_INFO,
 tempTraId,
 INFO_PP_READ_REQ,
 infoPpReadReq );
-}
+}*/
 // -----------------------------------------------------------------------------
-// CSatMessHandler::InfoPpReadResp
+// CSatMessHandler::InfoPpReadRespL
 // Breaks a INFO_PP_READ_RESP ISI-message.
 // -----------------------------------------------------------------------------
 //
-void CSatMessHandler::InfoPpReadResp
+/*void CSatMessHandler::InfoPpReadRespL
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp" );
+OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL" );
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL" );
 TUint8 traId( aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 INFO_PP_READ_RESP_OFFSET_TRANSID ) );
 TUint8 status( aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 INFO_PP_READ_RESP_OFFSET_STATUS ) );
-TFLOGSTRING2("TSY: CSatMessHandler::InfoPpReadResp - Status: %d",
+TFLOGSTRING2("TSY: CSatMessHandler::InfoPpReadRespL - Status: %d",
 status );
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp - Status: %hhu", status );
+OstTraceExt1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL - Status: %hhu", status );
 switch ( status )
 {
 case INFO_OK:
 if ( INFO_PP_ATK_MO_SM_CONTROL == pPFeatures [0] )
 {
 //Get the value of the MO SMS control feature
 if ( INFO_PP_FALSE != pPFeatures [1] )
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, MO SMS control supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, MO SMS control supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, MO SMS control supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, MO SMS control supported by ME product profile" );
 iMoSmsSupportedInPp = ETrue;
+TInt ret( KErrNone );
 // Continue MO SMS control check by checking
 // feature availability from USIM
 if ( UICC_CARD_TYPE_UICC == iCardType )
 {
 // USIM: Read MO-SMS control from byte 4
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 5 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
+User::LeaveIfError( ret );
 }
 else if ( UICC_CARD_TYPE_ICC == iCardType )
 {
-// SIM: Read MO-SMS control from byte 5
+// SIM: Read MO-SMS control from byte 10
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte5, 6 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte10, 9 );
+User::LeaveIfError( ret );
 }
 }
 else
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, MO SMS control not supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, MO SMS control not supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP3_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, MO SMS control not supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP3_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, MO SMS control not supported by ME product profile" );
 iMoSmsSupportedInPp = EFalse;
 // Feature was not activated in product profile
 // Set MoSmsCtrl object´s member
 // iIsMoSmsCtrlActivated to EFalse
 iTsySatMessaging->GetMoSmsCtrl()->Deactivate();
 if ( INFO_PP_ENHANCED_NETWORK_SELECTION == pPFeatures [0] )
 {
 //Get the value of the ENS feature
 if ( INFO_PP_FALSE != pPFeatures [1] )
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, INFO_PP_ENHANCED_NETWORK_SELECTION supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, INFO_PP_ENHANCED_NETWORK_SELECTION supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP8_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, INFO_PP_ENHANCED_NETWORK_SELECTION supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP8_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, INFO_PP_ENHANCED_NETWORK_SELECTION supported by ME product profile" );
 iEnsSupportedInPp = ETrue;
 }
 else
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, INFO_PP_ENHANCED_NETWORK_SELECTION not supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, INFO_PP_ENHANCED_NETWORK_SELECTION not supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP9_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, INFO_PP_ENHANCED_NETWORK_SELECTION not supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP9_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, INFO_PP_ENHANCED_NETWORK_SELECTION not supported by ME product profile" );
 iEnsSupportedInPp = EFalse;
 }
 }
 #endif // INFO_PP_ENHANCED_NETWORK_SELECTION
 if ( INFO_PP_SIM_OLD_POLL_INTERVAL == pPFeatures [0] )
 {
 //Get the value of the SIM_POLL_INTERVAL control feature
 if ( INFO_PP_FALSE != pPFeatures [1] )
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, INFO_PP_SIM_OLD_POLL_INTERVAL supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, INFO_PP_SIM_OLD_POLL_INTERVAL supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP4_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, INFO_PP_SIM_OLD_POLL_INTERVAL supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP4_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, INFO_PP_SIM_OLD_POLL_INTERVAL supported by ME product profile" );
 iOldPollIntervalSupportedInPp = ETrue;
 }
 else
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, INFO_PP_SIM_OLD_POLL_INTERVAL not supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, INFO_PP_SIM_OLD_POLL_INTERVAL not supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP5_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, INFO_PP_SIM_OLD_POLL_INTERVAL not supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP5_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, INFO_PP_SIM_OLD_POLL_INTERVAL not supported by ME product profile" );
 iOldPollIntervalSupportedInPp = EFalse;
 }
 }
 #endif // INFO_PP_SIM_OLD_POLL_INTERVAL
 //no else
 }
 break;
 }
 case INFO_NO_NUMBER:
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, Requested feature not defined in product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, Requested feature not defined in product profile" );
-OstTrace0( TRACE_NORMAL, DUP6_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, Requested feature not defined in product profile" );
+OstTrace0( TRACE_NORMAL, DUP6_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, Requested feature not defined in product profile" );
 #ifdef INFO_PP_ATK_MO_SM_CONTROL
 // Request was for INFO_PP_ATK_MO_SM_CONTROL
 if ( traId == iInfoPpMoSmsTraId )
 {
 // If the MO SMS feature is not defined in product profile,
 // internal Boolean used as feature supported ( for refresh )
 iMoSmsSupportedInPp = ETrue;
+TInt ret( KErrNone );
 // Continue as usual by checking feature avalability from USIM
 if ( UICC_CARD_TYPE_UICC == iCardType )
 {
 // USIM: Read MO-SMS control from byte 4
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 5 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );
+User::LeaveIfError( ret );
 }
 else if ( UICC_CARD_TYPE_ICC == iCardType )
 {
-// SIM: Read MO-SMS control from byte 5
+// SIM: Read MO-SMS control from byte 10
-UiccReadServiceTableReq( KUiccTrIdServiceTableByte5, 6 );
+ret = UiccReadServiceTableReq( KUiccTrIdServiceTableByte10, 9 );
+User::LeaveIfError( ret );
 }
 }
 #endif // INFO_PP_ATK_MO_SM_CONTROL
 break;
 }
 case INFO_FAIL:
 default:
 {
-TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadResp, - default Requested feature not supported by ME product profile" );
+TFLOGSTRING("TSY: CSatMessHandler::InfoPpReadRespL, - default Requested feature not supported by ME product profile" );
-OstTrace0( TRACE_NORMAL, DUP7_CSATMESSHANDLER_INFOPPREADRESP, "CSatMessHandler::InfoPpReadResp, - default Requested feature not supported by ME product profile" );
+OstTrace0( TRACE_NORMAL, DUP7_CSATMESSHANDLER_INFOPPREADRESPL_TD, "CSatMessHandler::InfoPpReadRespL, - default Requested feature not supported by ME product profile" );
 #ifdef INFO_PP_ATK_MO_SM_CONTROL
 // Request was for INFO_PP_ATK_MO_SM_CONTROL
 if ( traId == iInfoPpMoSmsTraId )
 {
 iMoSmsSupportedInPp = EFalse;
 // Zero iInfoPpMoSmsTraId if used. Not used by default.
 if ( traId == iInfoPpMoSmsTraId )
 {
 iInfoPpMoSmsTraId = 0;
 }
-}
+}*/
 // -----------------------------------------------------------------------------
 // CSatMessHandler::CheckTlvObjects
 // Validates every simple tlv object from proactive command
 // -----------------------------------------------------------------------------
 //
 TInt CSatMessHandler::CheckTlvObjects( CBerTlv& berTlv )
 {
 TFLOGSTRING("TSY: CSatMessHandler::CheckTlvObjects" );
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CHECKTLVOBJECTS, "CSatMessHandler::CheckTlvObjects" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_CHECKTLVOBJECTS_TD, "CSatMessHandler::CheckTlvObjects" );
 TInt ret( KErrNone );
 TPtrC8 dataPtr = berTlv.Data();
 TUint16 berTlvLength( berTlv.GetLength() );
 TInt totalLength = 0;
 // length of the simple TLV value must be 128-255, otherwise
 // it is treaded as error
 if( 0x80 > dataPtr[index] || 0xFF < dataPtr[index] )
 {
 TFLOGSTRING2("TSY: CSatMessHandler::CheckTlvObjects: corrupted simple tlv obj, len: %d even it should be 128-255", dataPtr[index] );
-OstTrace1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_CHECKTLVOBJECTS, "CSatMessHandler::CheckTlvObjects; corrupted simple tlv obj, len: %d even it should be 128-255", dataPtr[index] );
+OstTrace1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_CHECKTLVOBJECTS_TD, "CSatMessHandler::CheckTlvObjects; corrupted simple tlv obj, len: %d even it should be 128-255", dataPtr[index] );
 ret = KErrCorrupt;
 break;
 }
 }
 // length of the simple TLV value must be 0-127, otherwise
 // it is treaded as error
 if( 0x80 <= dataPtr[index] )
 {
 TFLOGSTRING2("TSY: CSatMessHandler::CheckTlvObjects: corrupted simple tlv obj, len: %d even it should be 0-127", dataPtr[index] );
-OstTrace1( TRACE_NORMAL, DUP2_CSATMESSHANDLER_CHECKTLVOBJECTS, "CSatMessHandler::CheckTlvObjects; corrupted simple tlv obj, len: %d even it should be 0-127", dataPtr[index] );
+OstTrace1( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_CHECKTLVOBJECTS_TD, "CSatMessHandler::CheckTlvObjects; corrupted simple tlv obj, len: %d even it should be 0-127", dataPtr[index] );
 ret = KErrCorrupt;
 break;
 }
 }
 // let's check does length from proactive command match to
 // calculated length
 if( berTlvLength != totalLength )
 {
 TFLOGSTRING3("TSY: CSatMessHandler::CheckTlvObjects: proactive command len (%d) and calculated len (%d) doesn't match", berTlvLength, totalLength );
-OstTraceExt2( TRACE_NORMAL, DUP3_CSATMESSHANDLER_CHECKTLVOBJECTS, "CSatMessHandler::CheckTlvObjects; proactive command len (%d) and calculated len (%d) doesn't match", berTlvLength, totalLength );
+OstTraceExt2( TRACE_NORMAL,  DUP3_CSATMESSHANDLER_CHECKTLVOBJECTS_TD, "CSatMessHandler::CheckTlvObjects; proactive command len (%d) and calculated len (%d) doesn't match", berTlvLength, totalLength );
 ret = KErrCorrupt;
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::SimMoSmsControlAvail( TUint8 aStatus )
 {
 TFLOGSTRING("TSY: CSatMessHandler::SimMoSmsControlAvail" );
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SIMMOSMSCONTROLAVAIL, "CSatMessHandler::SimMoSmsControlAvail" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SIMMOSMSCONTROLAVAIL_TD, "CSatMessHandler::SimMoSmsControlAvail" );
-if( SIM_SERV_OK == aStatus )
+// Activate the MO-SMS Control in SMS server. This is done by
+// sending a request SMS_RESOURCE_CONF_REQ to SMS server
+TBuf8<SIZE_SMS_RESOURCE_CONF_REQ + SIZE_SMS_SB_RESOURCE_CONF> data;
+// Append Configuration operation
+data.Append( SMS_RES_CONF_SET );
+// Number of Subblocks
+data.Append( 1 );
+// Add Subblock
+TIsiSubBlock ResourceConfReqSb(
+data,
+SMS_SB_RESOURCE_CONF,
+EIsiSubBlockTypeId16Len16 );
+if( aStatus )
 {
 // Set MoSmsCtrl object´s member iIsMoSmsCtrlActivated to ETrue
 iTsySatMessaging->GetMoSmsCtrl()->Activate();
-// Activate the MO-SMS Control in SMS server. This is done by
-// sending a request SMS_RESOURCE_CONF_REQ to SMS server
-TBuf8<SIZE_SMS_RESOURCE_CONF_REQ + SIZE_SMS_SB_RESOURCE_CONF> data;
-// Append Configuration operation
-data.Append( SMS_RES_CONF_SET );
-// Number of Subblocks
-data.Append( 1 );
-// Add Subblock
-//SMS_RESOURCE_IDS to zero SMS_RES_ID_MASK_MO_SM_INIT
-TIsiSubBlock ResourceConfReqSb(
-data,
-SMS_SB_RESOURCE_CONF,
-EIsiSubBlockTypeId16Len16 );
 TSatUtility::AppendWord( SMS_RES_ID_MO_SM_INIT, data );
-TSatUtility::AppendWord( SMS_RES_ID_MASK_MO_SM_INIT, data);
+}
-ResourceConfReqSb.CompleteSubBlock();
-SmsResoureConfReq(
-iTsySatMessaging->GetTransactionId(),
-SMS_RESOURCE_CONF_REQ,
-data );
-}
-// should not send SMS_RESOURCE_CONF_REQ if there is no MO SMS control enabled in SIM card
 else
 {
 // Set MoSmsCtrl object´s member IsMoSmsCtrlDeActivated to EFalse
 iTsySatMessaging->GetMoSmsCtrl()->Deactivate();
-}
+TSatUtility::AppendWord( 0x0000, data);
+}
+// SMS_RES_ID_MASK_MO_SM_INIT is the only "official" value for mask
+TSatUtility::AppendWord( SMS_RES_ID_MASK_MO_SM_INIT, data);
+ResourceConfReqSb.CompleteSubBlock();
+SmsResoureConfReq(
+iTsySatMessaging->GetTransactionId(),
+SMS_RESOURCE_CONF_REQ,
+data );
 }
 // -----------------------------------------------------------------------------
 // CSatMessHandler::UiccTerminalProfileReq
 // Send terminal profile
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::UiccTerminalProfileReq()
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCTERMINALPROFILEREQ, "CSatMessHandler::UiccTerminalProfileReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCTERMINALPROFILEREQ_TD, "CSatMessHandler::UiccTerminalProfileReq" );
 TFLOGSTRING("TSY: CSatMessHandler::UiccTerminalProfileReq");
 // Pointer to terminal profile buffer
 const TUint8* terminalProfilePtr( NULL );
 // Size of terminal profile
 TInt CSatMessHandler::UiccReadServiceTableReq(
 TUint8 aTrId,
 TUint16 aFileOffset )
 {
 TFLOGSTRING2("TSY: CSatMessHandler::UiccReadServiceTableReq, transaction ID: %d", aTrId );
-OstTraceExt1( TRACE_NORMAL, CSATMESSHANDLER_UICCREADSERVICETABLE, "CSatMessHandler::UiccReadServiceTableReq;aTrId=%hhu", aTrId );
+OstTraceExt1( TRACE_NORMAL,  CSATMESSHANDLER_UICCREADSERVICETABLE_TD, "CSatMessHandler::UiccReadServiceTableReq;aTrId=%hhu", aTrId );
 TIsiSend isiMsg( iPnSend->SendBufferDes() );
 isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );
 isiMsg.Set8bit(
 ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_TRANSID,
 // -----------------------------------------------------------------------------
 //
 TInt CSatMessHandler::UiccCatReq( TUint8 aCommand )
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccCatReq");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATREQ, "CSatMessHandler::UiccCatReq" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATREQ_TD, "CSatMessHandler::UiccCatReq" );
 TIsiSend isiMsg( iPnSend->SendBufferDes() );
 isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );
 isiMsg.Set8bit(
 ISI_HEADER_SIZE + UICC_CAT_REQ_OFFSET_TRANSID,
 const TUint8 aServiceType,    // Type of refresh
 TDes8& aFileList,             // List of files
 const TDesC8& aAid )          // Application ID (USIM)
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccCatReqRefresh");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATREQREFRESH, "CSatMessHandler::UiccCatReqRefresh" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATREQREFRESH_TD, "CSatMessHandler::UiccCatReqRefresh" );
 TUint8 numOfSubblocks( 1 ); // One mandatory subblock UICC_SB_REFRESH
 TUint8 uiccSbOffset(
 ISI_HEADER_SIZE + SIZE_UICC_CAT_REQ + SIZE_UICC_SB_REFRESH );
 TInt position( aFileList.LocateReverse( KRefreshMasterFileHeader ) );
 if ( KErrNotFound == position )
 {
 // File path is corrupted
 TFLOGSTRING("TSY: CSatMessHandler::SimAtkReq, File path is corrupted");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCCATREQREFRESH, "CSatMessHandler::UiccCatReqRefresh,File path is corrupted" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCCATREQREFRESH_TD, "CSatMessHandler::UiccCatReqRefresh,File path is corrupted" );
 break;
 }
-// Length of file path
+// Length of whole file path (file path + file id)
 TUint8 length( (TUint8) ( aFileList.Length() - position ) );
+// length of file path (without file id)
+TUint8 pathLength( (TUint8) ( length - KUiccFileIdLength ) );
 // File path
 TBuf8<KUiccFilePathLength> filePath(
 aFileList.Mid( position, length ) );
 // File ID is two last bytes
 TBuf8<KUiccFileIdLength> fileId(
 // File ID SFI is not known
 uiccSbApplPathBuf.Append( UICC_SFI_NOT_PRESENT );
 // Filler
 uiccSbApplPathBuf.Append( KUiccPadding );
 // File path length in bytes
-uiccSbApplPathBuf.Append( length );
+uiccSbApplPathBuf.Append( pathLength );
 // Filler
 uiccSbApplPathBuf.Append( KUiccPadding );
 // File path
-uiccSbApplPathBuf.Append( filePath );
+uiccSbApplPathBuf.Append( filePath.Mid( 0, pathLength ) );
 // Append subblock to ISI message
 isiMsg.CopyData( uiccSbOffset, uiccSbApplPath.CompleteSubBlock() );
 // Update subblock offset
 uiccSbOffset += uiccSbApplPathBuf.Length();
 const TDes8& aCommandDetails,         // Command details tlv
 const TDesC8& aBerTlvSpecificData,    // BER-TLV specific data
 const TUint8 aTransId )
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccCatReqTerminalResponse");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATREQTERMINALRESPONSE, "CSatMessHandler::UiccCatReqTerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATREQTERMINALRESPONSE_TD, "CSatMessHandler::UiccCatReqTerminalResponse" );
 TIsiSend isiMsg( iPnSend->SendBufferDes() );
 isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );
 isiMsg.Set8bit(
 ISI_HEADER_SIZE + UICC_CAT_REQ_OFFSET_TRANSID,
 }
 // Save terminal resp transaction id
 iTerminalRespTraId = aTransId;
 TFLOGSTRING2("TSY: CSatMessHandler::UiccCatReqTerminalResponse iTerminalRespTraId=%d", iTerminalRespTraId);
-OstTrace1( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCCATREQTERMINALRESPONSE, "CSatMessHandler::UiccCatReqTerminalResponse;iTerminalRespTraId=%d", iTerminalRespTraId );
+OstTrace1( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCCATREQTERMINALRESPONSE_TD, "CSatMessHandler::UiccCatReqTerminalResponse;iTerminalRespTraId=%d", iTerminalRespTraId );
 // Append subblock to ISI message
 isiMsg.CopyData(
 ISI_HEADER_SIZE + SIZE_UICC_CAT_REQ,
 uiccSbTerminalResponse.CompleteSubBlock() );
 // Handles UICC response for envelope
 // -----------------------------------------------------------------------------
 //
 TBool CSatMessHandler::UiccCatRespEnvelope( const TIsiReceiveC& aIsiMessage )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATENVELOPERESP, "CSatMessHandler::UiccCatRespEnvelope" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATENVELOPERESP_TD, "CSatMessHandler::UiccCatRespEnvelope" );
 TFLOGSTRING("TSY:CSatMessHandler::UiccCatRespEnvelope");
 TBool handled( EFalse );
 TUint8 trId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
 if ( KAtkSwDataNtfSw1NormalEnding == sw1
 && KAtkSwDataNtfSw2NormalEnding == sw2 )
 {
 // SIM responded OK. Remove stored envelope.
 iTsySatMessaging->GetSatTimer()->RemoveEnvelope( trId );
+if ( iTerminalRespTraId == trId )
+{
+iTsySatMessaging->SessionEnd( aIsiMessage );
+iTerminalRespTraId = KNoTransactionOngoing;
+}
 }
 else
 {
 // Problems in envelope sending, resend envelope if appropriate.
 if ( KErrNone == iTsySatMessaging->GetSatTimer()->
 ActivateEnvelopeResend( trId, sw1 ) )
 {
 TFLOGSTRING( "TSY:CSatMessHandler::UiccCatRespEnvelope, resending of envelope" );
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_UICCCATENVELOPERESP, "CSatMessHandler::UiccCatRespEnvelope,resending of envelope" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_UICCCATENVELOPERESP_TD, "CSatMessHandler::UiccCatRespEnvelope,resending of envelope" );
 // Envelope will be resent, mark as handled
 handled = ETrue;
 }
 }
 }
 else // Subblock is mandatory
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccCatRespEnvelope - Mandatory subblock UICC_SB_APDU not found");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCCATENVELOPERESP, "CSatMessHandler::UiccCatRespEnvelope- Mandatory subblock UICC_SB_APDU not found" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCCATENVELOPERESP_TD, "CSatMessHandler::UiccCatRespEnvelope- Mandatory subblock UICC_SB_APDU not found" );
 }
 return handled;
 }
 // -----------------------------------------------------------------------------
 //
 TBool CSatMessHandler::UiccCatRespTerminalResponse(
 const TIsiReceiveC& aIsiMessage )
 {
-OstTrace0( TRACE_NORMAL, DUP2_CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE, "CSatMessHandler::UiccCatRespTerminalResponse" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE_TD, "CSatMessHandler::UiccCatRespTerminalResponse" );
 TFLOGSTRING("TSY:CSatMessHandler::UiccCatRespTerminalResponse");
 TBool handled( EFalse );
 TUint8 trId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
 if ( KAtkSwDataNtfSw1NormalEnding == sw1
 && KAtkSwDataNtfSw2NormalEnding == sw2 )
 {
 TFLOGSTRING("CSatMessHandler::UiccCatRespTerminalResponse, - SIM SESSION END, 90 00 -");
-OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE, "CSatMessHandler::UiccCatRespTerminalResponse" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE_TD, "CSatMessHandler::UiccCatRespTerminalResponse" );
 iTsySatMessaging->SessionEnd( aIsiMessage );
 // Set flag to indicate that terminal response has been
 // processed by the SIM with status '90 00'.
 iTsySatMessaging->GetSatTimer()->
 SetProactiveCommandOnGoingStatus( EFalse );
+iTerminalRespTraId = KNoTransactionOngoing;
 }
 handled = ETrue;
 #ifdef INFO_PP_ENHANCED_NETWORK_SELECTION
 // Only if SET UP EVENT LIST TR is sent
 #endif // INFO_PP_ENHANCED_NETWORK_SELECTION
 }
 else // Subblock is not found
 {
 TFLOGSTRING("TSY: CSatMessHandler::UiccCatRespTerminalResponse - Subblock UICC_SB_APDU not found");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE, "CSatMessHandler::UiccCatRespTerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_UICCCATRESPTERMINALRESPONSE_TD, "CSatMessHandler::UiccCatRespTerminalResponse" );
 }
 return handled;
 }
 // -----------------------------------------------------------------------------
 //
 const TDesC8& CSatMessHandler::GetApplicationFileId()
 {
 TFLOGSTRING("TSY: CSatMessHandler::GetApplicationId");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETAPPLICATIONID, "CSatMessHandler::GetApplicationId" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETAPPLICATIONID_TD, "CSatMessHandler::GetApplicationId" );
 return iApplFileId;
 }
 // -----------------------------------------------------------------------------
 // Set status of iSatReady flag
 // -----------------------------------------------------------------------------
 //
 void CSatMessHandler::SetSatReadyStatus( TBool aSatReadyStatus )
 {
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SETSATREADYSTATUS, "CSatMessHandler::SetSatReadyStatus" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_SETSATREADYSTATUS_TD, "CSatMessHandler::SetSatReadyStatus" );
 TFLOGSTRING("TSY: CSatMessHandler::SetSatReadyStatus");
 iSatReady = aSatReadyStatus;
 }
 // -----------------------------------------------------------------------------
 //
 TBool CSatMessHandler::GetSatReadyStatus()
 {
 TFLOGSTRING("TSY: CSatMessHandler::GetSatReadyStatus");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETSATREADYSTATUS, "CSatMessHandler::GetSatReadyStatus" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETSATREADYSTATUS_TD, "CSatMessHandler::GetSatReadyStatus" );
 return iSatReady;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 TBool CSatMessHandler::GetTerminalProfileStatus()
 {
 TFLOGSTRING("TSY: CSatMessHandler::GetTerminalProfileStatus");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETTERMINALPROFILESTATUS, "CSatMessHandler::GetTerminalProfileStatus" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETTERMINALPROFILESTATUS_TD, "CSatMessHandler::GetTerminalProfileStatus" );
 return iTerminalProfileSent;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 const TDesC8& CSatMessHandler::GetClut()
 {
 TFLOGSTRING("TSY: CSatMessHandler::SetImageInstanceRequestStatus");
-OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_GETCLUT, "CSatMessHandler::GetClut" );
+OstTrace0( TRACE_NORMAL,  CSATMESSHANDLER_GETCLUT_TD, "CSatMessHandler::GetClut" );
 return iClutData;
 }
 // End of file

changeset 9	8486d82aef45
parent 8	6295dc2169f3