adaptationlayer/tsy/simatktsy_dll/src/satnotifications.cpp
changeset 0 63b37f68c1ce
child 5 8ccc39f9d787
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/adaptationlayer/tsy/simatktsy_dll/src/satnotifications.cpp	Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,9243 @@
+/*
+* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include "satnotifications.h"   // sat notifications class
+#include "satmessaging.h"       // sat messaging class
+#include "satmesshandler.h"     // sat message handler class
+#include "sattimer.h"           // sat timer class
+#include "ber_tlv.h"            // sat ber-tlv classes
+#include "satutil.h"            // sat utility class
+
+#include <tisi.h>               // isi message
+#include <net_modemisi.h>       // net server
+#include <gssisi.h>             // gss server
+#include <atkisi.h>             // atk server
+#include <uiccisi.h>            // uicc server
+#include <satcs.h>
+#include "osttracedefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "satnotificationstraces.h"
+#endif
+
+
+
+// CONSTANTS
+
+// Character code
+const TUint8 KPlusMarkCharacterCode                 = 0x2B;
+
+// Send SM
+const TUint8 KTPDUMandatoryFieldsSmsSubmitUdl       = 0x06;
+const TUint8 KTPDUMandatoryFieldsSmsCommandUdl      = 0x07;
+const TUint8 KTPDUMandatoryFieldsSmsSubmitDcs       = 0x05;
+const TUint8 KSmsVPFEnhanced                        = 0x01;
+const TUint8 KSmsVPFRelative                        = 0x02;
+const TUint8 KSmsVPFAbsolute                        = 0x03;
+const TUint8 KSmsVpFormatMask                       = 0x03;
+const TUint8 KSATSmsMTISubmitOrSubmitReport         = 0x01;
+const TUint8 KSmsDcsDefaultAlphabet                 = 0x00;
+const TUint8 KMinSmsTpduLength                      = 0x07;
+
+// Masks
+const TUint8 KMask0                                 = 0x00;
+const TUint8 KMask3                                 = 0x03;
+const TUint8 KMaskC0                                = 0xC0;
+const TUint8 KMaskF0                                = 0xF0;
+const TUint8 KMaskF3                                = 0xF3;
+const TUint8 KMaskFB                                = 0xFB;
+
+// Additional info
+const TUint8 KNoCause                               = 0x00;
+
+// SetUpCall
+const TUint8 KOnlyIfNotBusy                         = 0x00;
+const TUint8 KOnlyIfNotBusyWithRedial               = 0x01;
+const TUint8 KHoldOtherCalls                        = 0x02;
+const TUint8 KHoldOtherCallsWithRedial              = 0x03;
+const TUint8 KDisconnectOtherCalls                  = 0x04;
+const TUint8 KDisconnectOtherCallsWithRedial        = 0x05;
+
+// SetUpEventList
+const TUint8 KMTCall                                = 0x00;
+const TUint8 KCallConnected                         = 0x01;
+const TUint8 KCallDisconnected                      = 0x02;
+const TUint8 KLocationStatus                        = 0x03;
+const TUint8 KUserActivity                          = 0x04;
+const TUint8 KIdleScreenAvailable                   = 0x05;
+const TUint8 KCardReaderStatus                      = 0x06;
+const TUint8 KLanguageSelection                     = 0x07;
+const TUint8 KBrowserTermination                    = 0x08;
+const TUint8 KDataAvailable                         = 0x09;
+const TUint8 KChannelStatus                         = 0x0A;
+const TUint8 KAccessTechnologyChange                = 0x0B;
+const TUint8 KDisplayParamsChanges                  = 0x0C;
+const TUint8 KLocalConnection                       = 0x0D;
+
+
+// Timer management
+const TUint8 KMinTimerValue                         = 0;
+const TUint  KMaxTimerValueInSeconds                = 86400;
+
+// Launch browser
+const TUint8 KLaunchBrowserCmdQualifierNotUsed      = 0x01;
+const TUint8 KLaunchBrowserCmdQualifierReserved     = 0x04;
+const TUint8 KCsdBearer                             = 0x01;
+const TUint8 KGprsBearer                            = 0x03;
+const TUint8 KDefaultBrowser                        = 0x00;
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+const TUint8 KWMLBrowser                            = 0x01;
+const TUint8 KHTMLBrowser                           = 0x02;
+const TUint8 KXHTMLBrowser                          = 0x03;
+const TUint8 KCHTMLBrowser                          = 0x04;
+#endif
+
+// Bearer independent protocol
+const TUint8 KBipCsdBearer                          = 0x01;
+const TUint8 KBipGprsBearer                         = 0x02;
+const TUint8 KBipDefaultBearer                      = 0x03;
+const TUint8 KBipLocalLinkTechnologyIndependentBearer  = 0x04;
+const TUint8 KBipBluetoothBearer                    = 0x05;
+const TUint8 KBipIrDABearer                         = 0x06;
+const TUint8 KBipRS232Bearer                        = 0x07;
+const TUint8 KBipUSBBearer                          = 0x10;
+const TUint8 KBipSendDataImmediately                = 0x01;
+
+// Language notification
+const TUint8 KSpecificLanguage                      = 0x01;
+
+// Elementary files
+const TUint8 KRefresh1StLevelDedicatedFileHeader    = 0x7F;
+const TUint8 KRefresh2StLevelDedicatedFileHeader    = 0x5F;
+
+// SIM/ME Interface transport protocol type coding
+const TUint8 KProtocolUdp                           = 0x01;
+const TUint8 KProtocolTcp                           = 0x02;
+
+// Link Establishment
+const TUint8 KLinkEstablishmentMask                 = 0x01;
+
+// Reconnection mode
+const TUint8 KReconnectionModeMask                  = 0x02;
+
+
+// LOCAL FUNCTION PROTOTYPES
+
+// Declaration needed here for ARMV5 because method is used in Notifications
+// base, but method implementation is bit later.
+CSatNotificationsBase::TAllowedResults operator+(
+    const RSat::TPCmdResult aResultA, const RSat::TPCmdResult aResultB );
+
+// ==================== MEMBER FUNCTIONS ====================================
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::CSatNotificationsBase
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::CSatNotificationsBase
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        iSatMessHandler( aSatMessHandler ),
+        iSatMessaging( aSatMessaging ),
+        iTransId( KZero ),
+        iReqHandle( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::CSatNotificationsBase" );
+    iCommandDetails.Zero();
+
+    // Following results are accepted by all commands
+    iAllowedResults = RSat::KSuccess + RSat::KPartialComprehension
+        + RSat::KMissingInformation + RSat::KMeUnableToProcessCmd
+        + RSat::KCmdBeyondMeCapabilities + RSat::KCmdTypeNotUnderstood
+        + RSat::KCmdDataNotUnderstood + RSat::KCmdNumberNotKnown;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::~CSatNotificationsBase
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::~CSatNotificationsBase()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::~CSatNotificationsBase" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::CancelNotification
+// Cancels the current notification request
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotificationsBase::CancelNotification
+        (
+        const TTsyReqHandle aReqHandle  // Request handle
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CANCELNOTIFICATION, "CSatNotificationsBase::CancelNotification" );
+    TFLOGSTRING("TSY: CSatNotificationsBase::CancelNotification");
+
+    // Check that the handle is valid
+    if ( aReqHandle == iReqHandle )
+        {
+        iSatMessaging->ReqCompleted( aReqHandle, KErrCancel );
+        }
+    else
+        {
+        // Handle is not valid
+        iSatMessaging->ReqCompleted( aReqHandle, KErrCorrupt );
+        }
+
+    iReqHandle = NULL;
+
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TerminalResponse
+// Handles the terminal response of a proactive command
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotificationsBase::TerminalResponse
+        (
+        TDes8* /* aRsp */   // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TERMINALRESPONSE, "CSatNotificationsBase::TerminalResponse" );
+    // Base class does not do anything
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::GetCmdDetails
+// Returns a reference to member iCommandDetails
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TDes8& CSatNotificationsBase::GetCmdDetails()
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETCMDDETAILS, "CSatNotificationsBase::GetCmdDetails" );
+    return iCommandDetails;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::GetTransactionId
+// Returns the transaction identifier of the current PCmd.
+// This is a Nokia specific value found in ISI messages.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint8 CSatNotificationsBase::GetTransactionId()
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETTRANSACTIONID, "CSatNotificationsBase::GetTransactionId" );
+    return iTransId;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TsyReqHandle
+// Returns the TsyReqHandle of a request
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TTsyReqHandle CSatNotificationsBase::TsyReqHandle()
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TSYREQHANDLE, "CSatNotificationsBase::TsyReqHandle" );
+    return iReqHandle;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::CompleteRequest
+// Completes the Request notification
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotificationsBase::CompleteRequest
+        (
+        const TInt aError   // Possible error
+        )
+    {
+    OstTraceExt2( TRACE_NORMAL, CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest, Handle: %d, Error: %d", (TInt)iReqHandle, aError );
+    TFLOGSTRING3("CSatNotificationsBase::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d",
+               iReqHandle,
+               aError);
+    TTsyReqHandle tempReqHandle = iReqHandle;
+    iReqHandle = NULL;
+    iSatMessaging->ReqCompleted( tempReqHandle, aError );
+    TFLOGSTRING("CSatNotificationsBase::CompleteRequest. Request is now completed");
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest. Request is now completed" );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TAllowedResults::TAllowedResults
+// C++ default constructor of the nested class.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults::TAllowedResults() : iResultField( 0 )
+    {
+    }
+
+// -----------------------------------------------------------------------------
+// TBool CSatNotificationsBase::TAllowedResults::operator==
+// The equality operator (==) for TAllowedResults
+// -----------------------------------------------------------------------------
+//
+TBool CSatNotificationsBase::TAllowedResults::operator==
+        (
+        const RSat::TPCmdResult aResult
+        ) const
+    {
+    // Create mask from result for comparation
+    TAllowedResults mask;
+    mask = aResult;
+
+    // Compare with bit-wise AND operation
+    TBool match( iResultField & mask.iResultField );
+
+    // Unfortunately AND operator does not seem to work if the mask contains a
+    // value in the high order 32 bits of a 64 bit number. This case has to be
+    // checked with following macro.
+    if ( I64HIGH( mask.iResultField ) )
+        {
+        // Mask value is in the high order of the number so compare these.
+        match = I64HIGH( iResultField ) & I64HIGH( mask.iResultField );
+        }
+
+    // Open System Trace doesn't support tracing in nested classes
+    TFLOGSTRING3( "TAllowedResults::operator==: Bit Field: %08x %08x",
+        I64HIGH( iResultField ), I64LOW( iResultField ) );
+    TFLOGSTRING2( "TAllowedResults::operator==: Match: %d",
+        ( match ? 1 : 0 ) );
+
+    return match;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TAllowedResults::operator!=
+// The not-equal operator (!=) for TAllowedResults.
+// -----------------------------------------------------------------------------
+//
+TBool CSatNotificationsBase::TAllowedResults::operator!=
+        (
+        const RSat::TPCmdResult aResult
+        ) const
+    {
+    // Return the value of equals-operation (==) as inverted.
+    return !( *this == aResult );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TAllowedResults::operator=
+// The assignment operator (=) for TAllowedResults
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults&
+    CSatNotificationsBase::TAllowedResults::operator=
+        (
+        const RSat::TPCmdResult aResult
+        )
+    {
+    // Convert result to bit field and assing internal field to it.
+    iResultField = CreateBitField( aResult );
+
+    // Return reference to this
+    return *this;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::operator+=
+// The increment operator (+=) for TAllowedResults.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults&
+    CSatNotificationsBase::TAllowedResults::operator+=
+        (
+        const RSat::TPCmdResult aResult
+        )
+    {
+    // Append result to bit field by calling approriate plus operator
+    // and return reference to this
+    return *this = *this + aResult;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::operator+=
+// The increment operator (+=) for TAllowedResults.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults&
+    CSatNotificationsBase::TAllowedResults::operator+=
+        (
+        const CSatNotificationsBase::TAllowedResults aResults
+        )
+    {
+    // Append result fields together
+    iResultField = iResultField | aResults.iResultField;
+
+    // Return reference to this
+    return *this;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::TAllowedResults::operator+
+// The increment operator (+) for TAllowedResults.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults&
+    CSatNotificationsBase::TAllowedResults::operator+
+        (
+        const RSat::TPCmdResult aResult
+        )
+    {
+    // Convert to bit field and append to result field.
+    iResultField = iResultField | CreateBitField( aResult );
+
+    // Return reference to this
+    return *this;
+    }
+
+// -----------------------------------------------------------------------------
+// operator+
+// Friend increment operator (+) for adding two TPCmdResults together as
+// bitfield.
+// -----------------------------------------------------------------------------
+//
+CSatNotificationsBase::TAllowedResults operator+
+        (
+        const RSat::TPCmdResult aResultA,
+        const RSat::TPCmdResult aResultB
+        )
+    {
+    // Create temporary bit field and append values into it.
+    // Because internal TAllowedResults is used, this method is declared as a
+    // friend
+    CSatNotificationsBase::TAllowedResults temp;
+
+    temp = aResultA;
+    temp += aResultB;
+
+    return temp;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotificationsBase::CreateBitField
+// Converts result code into bitfield representation.
+// -----------------------------------------------------------------------------
+//
+inline TUint64
+    CSatNotificationsBase::TAllowedResults::CreateBitField
+        (
+        const RSat::TPCmdResult aResult
+        ) const
+    {
+    // Create a bitfield from a result by shifting '1' to the left.
+    // Number of shifts depend on the result number:
+    // ...0000 0001 = KSuccess (0x00)
+    // ...0000 0010 = KPartialComprehension(0x01)
+    // ...0001 0000 = KSuccessRequestedIconNotDisplayed(0x04)
+    // and so forth.
+
+    return static_cast<TInt64>( 1 ) << ( aResult );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyDisplayText::CSatNotifyDisplayText
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyDisplayText::CSatNotifyDisplayText
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iDisplayTextV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::CSatNotifyDisplayText" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
+        + RSat::KNoResponseFromUser + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyDisplayText::~CSatNotifyDisplayText
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyDisplayText::~CSatNotifyDisplayText()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::~CSatNotifyDisplayText" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyDisplayText::MessageReceived
+// Handles a DisplayText proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyDisplayText::MessageReceived( const TIsiReceiveC& aIsiMessage )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived" );
+    TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived");
+    // Completion return value
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    // Get command qualifier
+    TUint8 cmdQualifier(
+        commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+    // Save ISA/CellMo transaction id
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    // Test if pending request
+    if ( !iReqHandle )
+        {
+        TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived - Request Off");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived - Request Off" );
+
+        // Request not on, returning response immediately
+        iSatMessHandler->DisplayTextTerminalResp(
+            iTransId,                       // Transaction id
+            iCommandDetails,                // Command details tlv
+            RSat::KMeUnableToProcessCmd,    // Result
+            RSat::KNoAdditionalInfo );      // Additional info
+        }
+    else
+        {
+        // Pending request, adapts the PCmd ISI message.
+        // Let's fill the display text structure
+        RSat::TDisplayTextV2& displayTextV2 = ( *iDisplayTextV2Pckg )();
+        // Store command number
+        displayTextV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Priority scheme
+        if ( KPriorityMask & cmdQualifier )
+            {
+            // Display priority high
+            displayTextV2.iPriority = RSat::EHighPriority;
+            }
+        else
+            {
+            // Display priority normal
+            displayTextV2.iPriority = RSat::ENormalPriority;
+            }
+        // Clearing scheme
+        if ( KMessageClearMask & cmdQualifier)
+            {
+            // Wait for user to clear the message
+            displayTextV2.iClearScreenTrigger = RSat::EUserClear;
+            }
+        else
+            {
+            // Clear message after a delay
+            displayTextV2.iClearScreenTrigger = RSat::EClearAfterDelay;
+            }
+        // Immediate response TLV
+        CTlv immediateResponse;
+        TInt returnValue( berTlv.TlvByTagValue(
+            &immediateResponse,
+            KTlvImmediateResponseTag ) );
+        if ( KErrNotFound != returnValue )
+            {
+            // Respond immediately
+            displayTextV2.iImmediateRsp = RSat::EImmediateRsp;
+            }
+        else
+            {
+            // Do not respond immediately
+            displayTextV2.iImmediateRsp = RSat::ENoImmediateRsp;
+            }
+        // Text to display TLV
+        displayTextV2.iText.Zero();
+        CTlv textString;
+        returnValue = berTlv.TlvByTagValue( &textString,
+            KTlvTextStringTag );
+        if ( KErrNone == returnValue )
+            {
+            // Check if Icon Id found
+            // Iconid (optional)
+            TSatUtility::FillIconStructure(
+                berTlv, displayTextV2.iIconId );
+
+            // Text string tag is found, now
+            // check if the text string is null.
+            if ( textString.GetLength() )
+                {
+                // Convert and set text
+                TSatUtility::SetText( textString, displayTextV2.iText );
+                }
+            else if ( RSat::ENoIconId != displayTextV2.iIconId.iQualifier )
+                {
+                // Text string is a null data object and there is icon qualifier
+                // presented
+                // Return terminal response immediately.
+                iSatMessHandler->DisplayTextTerminalResp(
+                    iTransId,           // Transaction id
+                    iCommandDetails,                    // Command details TLV
+                    RSat::KCmdDataNotUnderstood,        // Result
+                    KNoCause );                         // Additional info
+                ret = KErrCorrupt;
+                }
+            }
+        else
+            {
+            iSatMessHandler->DisplayTextTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details TLV
+                RSat::KErrorRequiredValuesMissing,  // Result
+                KNoCause );                         // Additional info
+            ret = KErrCorrupt;
+            }
+        // Duration,( optional ) see 3GPP TS 31.111
+        TSatUtility::FillDurationStructure(
+            berTlv, displayTextV2.iDuration );
+
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyDisplayTextNotify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a DisplayText PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyDisplayText::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_NOTIFY, "CSatNotifyDisplayText::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyDisplayText::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iDisplayTextV2Pckg = static_cast< RSat::TDisplayTextV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KDisplayText );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyDisplayText::TerminalResponse
+// Handles a DisplayText terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyDisplayText::TerminalResponse
+        (
+        TDes8* aRsp     // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_TERMINALRESPONSE, "CSatNotifyDisplayText::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyDisplayText::TerminalResponse");
+    // Completion return value
+    TInt   ret( KErrNone );
+    // Additional info
+    TUint8 additionalInfo( 0 );
+    // Cast the input parameter to EtelSat data structure
+    RSat::TDisplayTextRspV1Pckg* aRspPckg =
+            reinterpret_cast<RSat::TDisplayTextRspV1Pckg*>( aRsp );
+    RSat::TDisplayTextRspV1& rspV1 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    // If there is Me (Mobile Equipment) error, additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = static_cast<TUint8>( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    // Prepare and send the terminal response to ISA/CellMo sw.
+    iSatMessHandler->DisplayTextTerminalResp(
+        iTransId,                                     // Transaction id
+        iCommandDetails,                             // Command details tlv
+        static_cast< TUint8 >( rspV1.iGeneralResult ),  // Result
+        additionalInfo );                            // Additional info
+    // return completion value.
+    return ret;
+
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInkey::CSatNotifyGetInkey
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetInkey::CSatNotifyGetInkey
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iGetInkeyV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::CSatNotifyGetInkey" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
+        + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInkey::~CSatNotifyGetInkey
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetInkey::~CSatNotifyGetInkey()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::~CSatNotifyGetInkey" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInkey::MessageReceived
+// Handles a GetInkey proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetInkey::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_MESSAGERECEIVED, "CSatNotifyGetInkey::MessageReceived" );
+    TFLOGSTRING( "TSY: CSatNotifyGetInkey::MessageReceived" );
+
+    // Completion return value
+    TInt ret( KErrNone );
+
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+
+    // Get command details
+    CTlv cmdDetails;
+    berTlv.TlvByTagValue( &cmdDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( cmdDetails.Data() );
+
+    // Save ISA/CellMo transaction id
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+
+    // Get command qualifier
+    TUint8 cmdQualifier( cmdDetails.GetShortInfo( ETLV_CommandQualifier ) );
+
+    // Test if pending request
+    if ( !iReqHandle )
+        {
+        RSat::TGetInkeyRspV2 error;
+        error.iGeneralResult = RSat::KMeUnableToProcessCmd;
+        error.iInfoType = RSat::KNoAdditionalInfo;
+
+        iSatMessHandler->GetInkeyTerminalResp(
+            iTransId,                    // Transaction Id
+            iCommandDetails,             // Command details
+            error                        // Error result
+            );
+        }
+    else
+        {
+        // Fill the get inkey structure
+        RSat::TGetInkeyV2& getInkeyV2 = ( *iGetInkeyV2Pckg )();
+
+        // Store command number
+        getInkeyV2.SetPCmdNumber(
+            cmdDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Transfer command qualifier parameter to ETelSat data structure
+        if ( KYesNoMask & cmdQualifier )
+            {
+            // The character set bits are disabled and yes/no response
+            // is requested
+            getInkeyV2.iRspFormat = RSat::EYesNo;
+            }
+        else
+            {
+            // The character set bits are enabled
+            if ( KAlphabetMask & cmdQualifier )
+                {
+                // Character set selected
+                if ( KUCS2AlphabetMask & cmdQualifier )
+                    {
+                    // UCS2 alphabet selected
+                    getInkeyV2.iRspFormat = RSat::ECharUcs2Alphabet;
+                    }
+                else
+                    {
+                    // SMS default alphabet selected
+                    getInkeyV2.iRspFormat = RSat::ECharSmsDefaultAlphabet;
+                    }
+                }
+            else
+            {
+            // Digits only selected
+            getInkeyV2.iRspFormat = RSat::EDigitOnly;
+            }
+
+        }
+        // Help information.
+        if ( KHelpAvailabilityMask & cmdQualifier )
+            {
+            // Help information available
+            getInkeyV2.iHelp = RSat::EHelpAvailable;
+            }
+        else
+            {
+            // No help
+            getInkeyV2.iHelp = RSat::ENoHelpAvailable;
+            }
+        // Response Mode
+        getInkeyV2.iMode = RSat::EGetInkeyRspModeNotSet;
+        if ( KImmediateDigitResponse & cmdQualifier )
+            {
+            // an immediate digit response (0-9, * and #) is requested.
+            getInkeyV2.iMode = RSat::EImmediateDigitRsp;
+            }
+        else
+            {
+            getInkeyV2.iMode = RSat::EUserRspDisplayed;
+            }
+        // Get Inkey text
+        CTlv textString;
+        if ( KErrNone == berTlv.TlvByTagValue(
+                &textString, KTlvTextStringTag ) )
+            {
+            // Convert and set text
+            TSatUtility::SetText( textString, getInkeyV2.iText );
+            }
+        else
+            {
+            RSat::TGetInkeyRspV2 error;
+            error.iGeneralResult = RSat::KErrorRequiredValuesMissing;
+            error.iInfoType = RSat::KNoAdditionalInfo;
+
+            iSatMessHandler->GetInkeyTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details TLV
+                error );                            // Error Result
+            ret = KErrCorrupt;
+            }
+        // IconId Optional
+        TSatUtility::FillIconStructure( berTlv,
+            getInkeyV2.iIconId );
+        // Duration
+        TSatUtility::FillDurationStructure( berTlv,
+            getInkeyV2.iDuration );
+        // Complete request to Etel
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInkey::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a GetInkey PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetInkey::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINKEY_NOTIFY, "CSatNotifyGetInkey::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2( "TSY: CSatNotifyGetInkey::Notify. Handle: %d", aReqHandle );
+
+    iReqHandle = aReqHandle;
+    iGetInkeyV2Pckg = static_cast< RSat::TGetInkeyV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KGetInkey );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInkey::TerminalResponse
+// Handles a GetInkey terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyGetInkey::TerminalResponse
+        (
+        TDes8* aRsp // Response packet from ETel
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_TERMINALRESPONSE, "CSatNotifyGetInkey::TerminalResponse" );
+    TFLOGSTRING("TSY: CSatNotifyGetInkey::TerminalResponse" );
+
+    TInt ret( KErrNone );
+
+    RSat::TGetInkeyRspV2Pckg& aRspPckg =
+            reinterpret_cast<RSat::TGetInkeyRspV2Pckg&>( *aRsp );
+    RSat::TGetInkeyRspV2& rspV2 = aRspPckg();
+
+    // Checking that infotype is valid
+    switch ( rspV2.iInfoType )
+        {
+        case RSat::KMeProblem:
+        case RSat::KTextString:
+            {
+            if ( !rspV2.iAdditionalInfo.Length() )
+                {
+                // These info types require additional info
+                ret = KErrCorrupt;
+                }
+            break;
+            }
+        case RSat::KNoAdditionalInfo:
+            {
+            if ( rspV2.iAdditionalInfo.Length() )
+                {
+                // For this type, AI shouldn't be present
+                ret = KErrCorrupt;
+                }
+            break;
+            }
+        default:
+            {
+            // Unexpected value
+            ret = KErrCorrupt;
+            break;
+            }
+        }
+
+    // Checking that the response type is valid
+    switch ( rspV2.iRspFormat )
+        {
+        case RSat::EDigitOnly:
+        case RSat::ECharSmsDefaultAlphabet:
+        case RSat::ECharUcs2Alphabet:
+        case RSat::EYesNo:
+            {
+            // Ok
+            break;
+            }
+        default:
+            {
+            // Unexpected value
+            ret = KErrCorrupt;
+            break;
+            }
+        }
+
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Unexpected value
+        ret = KErrCorrupt;
+        }
+
+    if ( ( RSat::ETimeUnitNotSet == rspV2.iDuration.iTimeUnit ) )
+        {
+        // Time should have been initialized
+        ret = KErrCorrupt;
+        }
+
+    iSatMessHandler->GetInkeyTerminalResp(
+        iTransId,                                  // Transaction id
+        iCommandDetails,                           // Command details
+        rspV2 );                                   // Response data
+
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInput::CSatNotifyGetInput
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetInput::CSatNotifyGetInput
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iGetInputV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::CSatNotifyGetInput" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
+        + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInput::~CSatNotifyGetInput
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetInput::~CSatNotifyGetInput()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::~CSatNotifyGetInput" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInput::MessageReceived
+// Handles a GetInput proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetInput::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived" );
+    TFLOGSTRING("CSatNotifyGetInput::MessageReceived");
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        TBuf<1> emptyString;
+        // Request not on, returning response immediately
+        iSatMessHandler->GetInputTerminalResp(
+            iTransId,                          // Transaction id
+            iCommandDetails,                    // Command details tlv
+            RSat::KMeUnableToProcessCmd,        // Result
+            KNoCause,                           // Additional info, KNoCause: 0
+            emptyString,                        // No string
+            RSat::ESmsDefaultAlphabetUnpacked );// data coding scheme
+
+        }
+    else
+        {
+        // Fill the get input structure
+        RSat::TGetInputV1& getInputV1 = ( *iGetInputV1Pckg )();
+        // Store command number
+        getInputV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Get command qualifier
+        TUint8 cmdQualifier(
+            commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+        // First comes the user input display option
+        if ( KUserInputMask & cmdQualifier )
+            {
+            // User input hidden
+            getInputV1.iInputDisplayOption = RSat::EHideUserInput;
+            }
+        else
+            {
+            // User input shown
+            getInputV1.iInputDisplayOption = RSat::EDisplayUserInput;
+            }
+        // Next the response format expected
+        if ( KUCS2AlphabetMask & cmdQualifier )
+            {
+            getInputV1.iRspFormat = RSat::EUcs2Alphabet;
+            }
+        else if ( KAlphabetMask & cmdQualifier )
+            {
+            if ( KGetInputSmsPackedMask & cmdQualifier )
+                {
+                // SMS default alphabet
+                getInputV1.iRspFormat = RSat::ESmsDefaultAlphabetPacked;
+                }
+            else
+                {
+                getInputV1.iRspFormat = RSat::ESmsDefaultAlphabetUnpacked;
+                }
+            }
+        else
+            {
+            if  ( KGetInputSmsPackedMask & cmdQualifier )
+                {
+                // Digit only
+                getInputV1.iRspFormat = RSat::EDigitOnlyPacked;
+                }
+            else
+                {
+                getInputV1.iRspFormat = RSat::EDigitOnlyUnpacked;
+                }
+            }
+        // Help information.
+        if ( KHelpAvailabilityMask & cmdQualifier )
+            {
+            // Help information available
+            getInputV1.iHelp = RSat::EHelpAvailable;
+            }
+        else
+            {
+            // No help
+            getInputV1.iHelp = RSat::ENoHelpAvailable;
+            }
+
+        // Get Input text
+        getInputV1.iText.Zero();
+        CTlv textString;
+        TInt returnValue( berTlv.TlvByTagValue( &textString,
+                                                KTlvTextStringTag ) );
+         if ( KErrNone == returnValue )
+            {
+            // Set and conver text
+            TSatUtility::SetText( textString, getInputV1.iText );
+            }
+        else
+            {
+            TBuf<1> emptyString;
+            iSatMessHandler->GetInputTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details tlv
+                RSat::KErrorRequiredValuesMissing,  // Result
+                KNoCause,                           // KNoCause: 0
+                emptyString,                        // No string
+                RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme
+
+            ret = KErrCorrupt;
+            }
+        TFLOGSTRING2("TSY: GetInput, text: %S", &getInputV1.iText );
+        OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived GetInput, text: %S", getInputV1.iText );
+
+        // Response length expected
+        CTlv responseLength;
+        returnValue = berTlv.TlvByTagValue( &responseLength,
+                                            KTlvResponseLengthTag );
+        if ( KErrNone == returnValue )
+            {
+            // Set minimum response length
+            getInputV1.iRspLength.iMinRspLength =
+                responseLength.GetShortInfo( ETLV_MinimumLengthOfResponse );
+
+            if ( RSat::KGetInputTextMaxSize <
+                getInputV1.iRspLength.iMinRspLength )
+                {
+                TBuf<1> emptyString;
+                iSatMessHandler->GetInputTerminalResp(
+                    iTransId,                           // Transaction id
+                    iCommandDetails,                    // Command details tlv
+                    RSat::KCmdDataNotUnderstood,        // Result
+                    KNoCause,                           // KNoCause: 0
+                    emptyString,                        // No string
+                    RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme
+
+                ret = KErrCorrupt;
+                }
+            // Set maximum response length
+            getInputV1.iRspLength.iMaxRspLength =
+                responseLength.GetShortInfo( ETLV_MaximumLengthOfResponse );
+            }
+        else
+            {
+            // Mandatory reponse length tlv is missing
+            TBuf<1> emptyString;
+            iSatMessHandler->GetInputTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details tlv
+                RSat::KErrorRequiredValuesMissing,  // Result
+                KNoCause,                           // KNoCause: 0
+                emptyString,                        // No string
+                RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme
+
+            ret = KErrCorrupt;
+            }
+        // Default text to display (optional)
+        getInputV1.iDefaultText.Zero();
+        returnValue = berTlv.TlvByTagValue( &textString, KTlvDefaultTextTag );
+        // If default text exist
+        if ( KErrNone == returnValue )
+            {
+            TSatUtility::SetText( textString, getInputV1.iDefaultText );
+            }
+        // Iconid ( optional )
+        TSatUtility::FillIconStructure( berTlv, getInputV1.iIconId );
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInput::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a GetInput PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetInput::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINPUT_NOTIFY, "CSatNotifyGetInput::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyGetInput::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iGetInputV1Pckg = static_cast< RSat::TGetInputV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KGetInput );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetInput::TerminalResponse
+// Handles a GetInput terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyGetInput::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_TERMINALRESPONSE, "CSatNotifyGetInput::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyGetInput::TerminalResponse");
+    TInt ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+
+    RSat::TGetInputRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TGetInputRspV1Pckg* >( aRsp );
+    RSat::TGetInputRspV1& rspV1 = ( *aRspPckg ) ();
+
+    // Checking that the response type is valid. If additional info contain
+    // a text string, response format has to be set.
+    if ( RSat::EGetInputRspFormatNotSet == rspV1.iRspFormat
+        && RSat::KTextString == rspV1.iInfoType )
+        {
+        ret = KErrCorrupt;
+        }
+
+    // Check the additional info
+    if ( ( RSat::KTextString == rspV1.iInfoType )
+         || ( RSat::KSuccess  == rspV1.iGeneralResult ) )
+        {
+        // Making sure first that the string is not empty
+        if ( RSat::KNoAdditionalInfo != rspV1.iInfoType
+                && 0 == rspV1.iAdditionalInfo.Length() )
+            {
+            ret = KErrCorrupt;
+            }
+        }
+    // Check that general result values are valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Entity) error, additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->GetInputTerminalResp(
+        iTransId,                                 // Transaction id
+        iCommandDetails,                          // Command details Tlv
+        static_cast< TUint8 >(
+        rspV1.iGeneralResult ),                   // Result
+        additionalInfo,                           // Additional info
+        rspV1.iAdditionalInfo,                    // Input text
+        static_cast< TUint8 >( rspV1.iRspFormat ) );    // Resp. format
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPlayTone::CSatNotifyPlayTone
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPlayTone::CSatNotifyPlayTone
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iPlayToneV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::CSatNotifyPlayTone" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPlayTone::~CSatNotifyPlayTone
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPlayTone::~CSatNotifyPlayTone()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::~CSatNotifyPlayTone" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPlayTone::MessageReceived
+// Handles a PlayTone proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPlayTone::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_MESSAGERECEIVED, "CSatNotifyPlayTone::MessageReceived" );
+    TFLOGSTRING("CSatNotifyPlayTone::MessageReceived");
+    //get ber tlv
+    CBerTlv berTlv;
+    TInt returnValue( KErrNone );
+    returnValue = berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->PlayToneTerminalResp(
+            iTransId,
+            iCommandDetails,
+            RSat::KMeUnableToProcessCmd,
+            KNoCause ); // KNoCause: 0
+        }
+    else
+        {
+        // Fill the play tone structure
+        RSat::TPlayToneV2& playToneV2 = ( *iPlayToneV2Pckg )();
+        // command number
+        playToneV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+
+        // Alpha ID string (optional)
+        CTlv alphaIdentifier;
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+            KTlvAlphaIdentifierTag );
+        if ( KErrNotFound != returnValue )
+            {
+            TUint16 alphaIdLength = alphaIdentifier.GetLength();
+            if ( alphaIdLength )
+                {
+                // get the alpha id
+                TPtrC8 sourceString;
+                sourceString.Set(
+                    alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceString ,
+                    playToneV2.iAlphaId.iAlphaId );
+                }
+            // Set Alpha ID status
+            if ( playToneV2.iAlphaId.iAlphaId.Length() )
+                {
+                playToneV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                }
+            else
+                {
+                playToneV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                }
+            }
+        else
+            {
+            playToneV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            }
+
+        // Tone selection (optional)
+        playToneV2.iTone = RSat::KToneNotSet;
+        CTlv tone;
+        returnValue = berTlv.TlvByTagValue( &tone, KTlvToneTag );
+        if (returnValue != KErrNotFound)
+            {
+            playToneV2.iTone = ( RSat::TTone ) tone.GetShortInfo( ETLV_Tone );
+            }
+        // Duration of the tone (optional)
+        TSatUtility::FillDurationStructure( berTlv,
+            playToneV2.iDuration );
+        // Icond Id (optional)
+        TSatUtility::FillIconStructure( berTlv,
+            playToneV2.iIconId );
+
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPlayTone::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a PlayTone PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPlayTone::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYPLAYTONE_NOTIFY, "CSatNotifyPlayTone::Notify Handle: %u", aReqHandle );
+
+    TFLOGSTRING2("CSatNotifyPlayTone::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iPlayToneV2Pckg = static_cast< RSat::TPlayToneV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KPlayTone );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPlayTone::TerminalResponse
+// Handles a PlayTone terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyPlayTone::TerminalResponse
+        (
+        TDes8* aRsp     // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_TERMINALRESPONSE, "CSatNotifyPlayTone::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyPlayTone::TerminalResponse");
+    TInt ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TPlayToneRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TPlayToneRspV1Pckg* >( aRsp );
+    RSat::TPlayToneRspV1& rspV1 = ( *aRspPckg ) ();
+    // Check that general result value is valid.
+    // Note: When the phone is in silent mode, KMeUnableToProcessCmd
+    // is returned as a result, with no additional info.
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    // If there is Me (Mobile Entity) error, additional info is needed
+    if ( RSat::KMeProblem == rspV1.iInfoType )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() )
+            {
+            additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->PlayToneTerminalResp(
+        iTransId,                                       // Transaction Id
+        iCommandDetails,                                // Command number
+        TUint8( rspV1.iGeneralResult ),                 // Result
+        additionalInfo );                               // Additional info
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollInterval::CSatNotifyPollInterval
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPollInterval::CSatNotifyPollInterval
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::CSatNotifyPollInterval" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollInterval::~CSatNotifyPollInterval
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPollInterval::~CSatNotifyPollInterval()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::~CSatNotifyPollInterval" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollInterval::MessageReceived
+// Handles a PollInterval proactive command ISI message.
+// No ETel pending request is required.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPollInterval::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived" );
+    TFLOGSTRING("CSatNotifyPollInterval::MessageReceived");
+    //get ber tlv
+    CBerTlv berTlv;
+    TInt returnValue( KErrNone );
+    berTlv.BerTlv( aIsiMessage );
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    TUint16 anIntervalInSeconds( KDefaultPollInterval );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    // Duration of the interval
+    CTlv duration;
+    returnValue = berTlv.TlvByTagValue( &duration, KTlvDurationTag );
+    if ( KErrNone != returnValue )
+        {
+        // Required values are missing
+        iSatMessHandler->PollIntervalTerminalResp( iTransId, iCommandDetails,
+            RSat::KErrorRequiredValuesMissing, RSat::KNoSpecificMeProblem, 0);
+        }
+    else
+        {
+        TUint8 timeIntv( duration.GetShortInfo( ETLV_TimeInteval ) );
+
+        // Time Interval 0 is SIM server's default value (25 seconds)
+        if ( 0 != timeIntv )
+            {
+            TUint8 durationTimeUnit( duration.GetShortInfo( ETLV_TimeUnit ) );
+
+            switch (durationTimeUnit)
+                {
+                case KMinutes:
+                    {
+                    anIntervalInSeconds = timeIntv * 60;
+                    break;
+                    }
+                case KSeconds:
+                    {
+                    anIntervalInSeconds = timeIntv;
+                    break;
+                    }
+                case KTenthsOfSeconds:
+                    {
+                        // Rounding
+                    if ( 5 >= ( timeIntv % 10 ) )
+                        {
+                        // if the intervals the ME can offer are equidistant
+                        // (higher and lower) from the SIM's request, the ME shall
+                        // respond with the lower interval of the two.
+                        anIntervalInSeconds = static_cast<TUint8> (timeIntv / 10 );
+                        }
+                    else
+                        {
+                        anIntervalInSeconds = static_cast<TUint8> ( (timeIntv / 10) + 1);
+                        }
+                    break;
+                    }
+                default:
+                    {
+                    returnValue = KErrNotFound;
+                    TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, Time unit did not match.");
+                    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, Time unit did not match." );
+                    // Command data not understood
+                    iSatMessHandler->PollIntervalTerminalResp( iTransId, iCommandDetails,
+                    RSat::KCmdDataNotUnderstood, RSat::KNoSpecificMeProblem, 0);
+                    break;
+                    }
+                }//switch
+
+            // Check interval limits
+            if ( KMinPollInterval > anIntervalInSeconds )
+                {
+                anIntervalInSeconds = KMinPollInterval;
+                }
+            else if ( KMaxPollInterval < anIntervalInSeconds )
+                {
+                if ( iSatMessHandler->OldPollInterval() )
+                    {
+                    TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived MaxPolInterval");
+                    OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived MaxPolInterval" );
+                    anIntervalInSeconds = KMaxPollInterval;
+                    }
+                else
+                    {
+                    TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, DefaultPollInterval");
+                    OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, DefaultPollInterval" );
+                    // Use SIM server's default value (0)
+                    anIntervalInSeconds = KDefaultPollInterval;
+                    }
+                }
+            }
+        else
+            {
+            // Use SIM server's default value (0)
+            anIntervalInSeconds = KDefaultPollInterval;
+            }
+
+        if ( KErrNone == returnValue )
+            {
+
+            // A PCmd PollingOff may be executed.
+            iSatMessHandler->SetPollingOff( EFalse );
+            // Send SetPollInterval request to ISA CellMo side. The terminal response
+            // will be sent to ISA CellMo side after SetPollInterval response.
+            iSatMessHandler->SetPollingInterval(
+                iTransId,
+                static_cast<TUint8>( anIntervalInSeconds ) );
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollInterval::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a PollInterval PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPollInterval::Notify
+        (
+        const TTsyReqHandle /*aReqHandle*/, // Request handle
+        TDes8*              /*aDataPtr*/    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_NOTIFY, "CSatNotifyPollInterval::Notify" );
+    // PollInterval is completely implemented by SimAtkTsy. Client
+    // insn't notified about the command.
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::CSatNotifySetUpMenu
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpMenu::CSatNotifySetUpMenu
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSetUpMenuV2Pckg( NULL ),
+        iSatIsiMsg( NULL ),
+        iItemsNextIndicatorRemoved( EFalse )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::CSatNotifySetUpMenu" );
+    TFLOGSTRING("CSatNotifySetUpMenu::CSatNotifySetUpMenu");
+    iToolKitName.Zero();
+
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::~CSatNotifySetUpMenu
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpMenu::~CSatNotifySetUpMenu()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::~CSatNotifySetUpMenu" );
+    TFLOGSTRING("CSatNotifySetUpMenu::~CSatNotifySetUpMenu");
+    if ( iSatIsiMsg )
+        {
+        delete iSatIsiMsg;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::MessageReceived
+// Handles a SetUpMenu proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpMenu::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived" );
+    TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+    // get ber tlv
+    CBerTlv berTlv;
+    returnValue = berTlv.BerTlv( aIsiMessage );
+     //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+     // Get command qualifier
+    TUint8 cmdQualifier( commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request is not pending. Store pcmd for later use
+        // This may happen e.g. when changing ME's language (warm reset)
+        if ( iSatIsiMsg )
+            {
+            // first clear buffer if there's already data
+            delete iSatIsiMsg;
+            iSatIsiMsg = NULL;
+            }
+        // Alloc memory
+        iSatIsiMsg = aIsiMessage.GetBuffer().Alloc();
+
+        if ( iSatIsiMsg )
+            {
+            TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, pcmd saved");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, pcmd saved" );
+            }
+        else
+            {
+            TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, \
+                out of memory unable to buffer received cmd");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, out of memory unable to buffer received cmd" );
+            iSatMessHandler->SetUpMenuTerminalResp( iTransId,
+                                                iCommandDetails,
+                                                RSat::KMeUnableToProcessCmd,
+                                                NULL );
+            ret = KErrCorrupt;
+            }
+        }
+    RSat::TSetUpMenuV2 menu;
+    // Store command number
+    menu.SetPCmdNumber(
+        commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+    // Selection preference
+    menu.iPreference = RSat::ESelectionPreferenceNotSet;
+    if ( cmdQualifier & KSelectionUsingSoftKey )
+        {
+        menu.iPreference = RSat::ESoftKeyPreferred;
+        }
+    else
+        {
+        menu.iPreference = RSat::ENoSelectionPreference;
+        }
+    // Alpha Id string (optional)
+    menu.iAlphaId.iAlphaId.Zero();
+    //get alpha identifier tlv
+    CTlv alphaIdentifier;
+    returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+                                        KTlvAlphaIdentifierTag );
+    if ( KErrNone != returnValue )
+        {
+
+        iSatMessHandler->SetUpMenuTerminalResp(
+                                    iTransId,
+                                    iCommandDetails,
+                                    RSat::KErrorRequiredValuesMissing,
+                                    RSat::KNoAdditionalInfo );
+        ret = KErrCorrupt;
+        }
+    else
+        {
+        TUint16 alphaIdLength = alphaIdentifier.GetLength();
+        TFLOGSTRING2("TSY: Alpha ID length:%d", alphaIdLength );
+        OstTraceExt1( TRACE_NORMAL, DUP3_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Alpha ID: %hu", alphaIdLength );
+        if ( alphaIdLength > RSat::KAlphaIdMaxSize )
+            {
+            // String too long
+            ret = KErrCorrupt;
+            }
+        else if ( alphaIdLength )
+            {
+            TPtrC8 temp;
+            // get the alpha id
+            temp.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+            // convert and set the alpha id
+            TSatUtility::SetAlphaId( temp , menu.iAlphaId.iAlphaId );
+            // Set SAT toolikit name, send SAT SMS logging purpose
+            iToolKitName.Copy( menu.iAlphaId.iAlphaId );
+            TFLOGSTRING2("TSY: SetUpMenu iToolKitName:%S",
+                  &iToolKitName );
+            OstTraceExt1( TRACE_NORMAL, DUP4_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived SetUpMenu iToolKitName: %S", iToolKitName );
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived,\
+                Wrong length of alpha id.");
+            OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong length of alpha id." );
+            }
+        // Alpha Id status
+        if ( menu.iAlphaId.iAlphaId.Length() )
+            {
+            menu.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+            }
+        else
+            {
+            menu.iAlphaId.iStatus = RSat::EAlphaIdNull;
+            }
+        // Help information.
+        if ( commandDetails.GetShortInfo( ETLV_CommandQualifier )
+              & KHelpAvailabilityMask )
+            {
+            // Help information available
+            menu.iHelp = RSat::EHelpAvailable;
+            }
+        else
+            {
+            // No help
+            menu.iHelp = RSat::ENoHelpAvailable;
+            }
+        // Icon identifier
+        TSatUtility::FillIconStructure( berTlv, menu.iIconId );
+        // Item Icon identifier list
+        CTlv itemsIconIdentifierList;
+        TInt retValue = berTlv.TlvByTagValue( &itemsIconIdentifierList,
+                                         KTlvItemIconIdentifierListTag );
+        TPtrC8 iconIdList;
+        menu.iIconListQualifier = RSat::EIconQualifierNotSet;
+
+        if( KErrNone == retValue )
+            {
+            TUint8 iIconListQualifier( itemsIconIdentifierList.GetShortInfo(
+                                             ETLV_IconListQualifier ) );
+            iconIdList.Set( itemsIconIdentifierList.GetData( ETLV_IconIdentifierList ));
+
+            if( iIconListQualifier )
+                {
+                menu.iIconListQualifier = RSat::ENotSelfExplanatory;
+                }
+            else
+                {
+                menu.iIconListQualifier = RSat::ESelfExplanatory;
+                }
+            }
+        else if ( KErrNotFound == retValue )
+            {
+            menu.iIconListQualifier = RSat::ENoIconId;
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived, \
+                Wrong return value of icon identifier list.");
+            OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong return value of icon identifier list." );
+            }
+
+        //Items Data
+        TInt itemNbr( 0 );
+        CTlv itemsData;
+        returnValue = berTlv.TlvByTagValue( &itemsData, KTlvItemTag,
+                                            itemNbr );
+        TUint8 numberOfItemData( 0 );
+        TUint16 stringLength( 0 );
+        if( !returnValue )
+            {
+            CTlv itemsDataTemp;
+            stringLength = ( itemsData.GetLength());
+            TInt ret(KErrNone);
+            // Set numberOfItemData
+            while ( KErrNone == ret )
+                {
+                numberOfItemData++;
+                ret = berTlv.TlvByTagValue( &itemsDataTemp, KTlvItemTag,
+                                                numberOfItemData );
+                }
+            }
+
+        //Item Next Action Indicator
+        CTlv itemNextActionIndicator;
+        retValue = berTlv.TlvByTagValue( &itemNextActionIndicator,
+                                         KTlvItemsNextActionIndicatorTag );
+        TPtrC8 itemNextIndicator;
+        if ( KErrNone == retValue )
+            {
+            TPtrC8 itemNextIndicatorTemp;
+            itemNextIndicatorTemp.Set(
+                 itemNextActionIndicator.GetData( ETLV_ItemsNextActionIndicator ));
+
+            //In case the number of items in this list does not match the number
+            //of items in the menu the Items Next Action Indicator list is ignored by ME
+            if(itemNextIndicatorTemp.Length() != numberOfItemData )
+                {
+                iItemsNextIndicatorRemoved = ETrue;
+                }
+            else
+                   {
+                itemNextIndicator.Set(itemNextIndicatorTemp);
+                   }
+            }
+
+        //if first item is NULL -> remove existing menu
+        if( stringLength != 0 )
+            {
+            for ( TInt8 i( 0 ) ; ( KErrNone == ret )
+                && ( KErrNone == returnValue ) ; i++ )
+                {
+                // Filling up the menu items
+                RSat::TItem newItem;
+                // Suffle through all the menu items
+                stringLength = 0;
+                TFLOGSTRING2("TSY: item number:%d", i );
+                OstTraceExt1( TRACE_NORMAL, DUP7_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Item number: %hhd", i );
+                // Fill the newitem
+                newItem.iItemId = itemsData.GetShortInfo( ETLV_IdentifierOfItem );
+                stringLength = itemsData.GetLength();
+                stringLength--;
+                TPtrC8 itemData = itemsData.GetData( ETLV_TextStringOfItem );
+                // Menu item string, coded as EFadn (3gpp 11.11)
+                newItem.iItemString.Zero();
+                if ( ( KUCS2ArabicCoding == itemData[0] )
+                    || ( KUCS2GreekCoding == itemData[0] )
+                    || ( KUCS2TurkishCoding == itemData[0] ) )
+                    {
+                    TSatUtility::ConvertAlphaFieldsToUnicode( itemData,
+                        newItem.iItemString );
+                    }
+                else
+                    {
+                    TSatUtility::ConvertSms7ToUnicode16( newItem.iItemString,
+                          itemData );
+                    }
+                TFLOGSTRING2("TSY: SetUpMenu newItem.iItemString:%S",
+                    &newItem.iItemString );
+                OstTraceExt1( TRACE_NORMAL, DUP8_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, newItem.iItemString: %S", newItem.iItemString );
+                // Adding the new menuitem
+                if( NULL != iconIdList.Size()  && ( i < iconIdList.Length() ) )
+                    {
+                    if( ( NULL != itemNextIndicator.Size() )
+                        && ( i < itemNextIndicator.Length() ) )
+                        {
+                        //Menu item with item next idicator and icon identifier
+                        if ( KErrNoMemory == menu.AddItem( newItem,
+                             itemNextIndicator[i], iconIdList[i] ) )
+                            {
+                            // Too many or long menu items
+                            ret = KErrCorrupt;
+                            }
+                        }
+                    //menu item with icon identifier
+                    else if ( KErrNoMemory == menu.AddItemIcon( newItem,
+                                                                iconIdList[i] ) )
+                        {
+                        // Too many or long menu items
+                        ret = KErrCorrupt;
+                        }
+                    else
+                        {
+                        // All ok
+                        }
+                    }
+                else
+                    {
+                    if( ( NULL != itemNextIndicator.Size() )
+                        && ( i < itemNextIndicator.Length() ) )
+                        {
+                        //menu item with item next indicator
+                        if ( KErrNoMemory == menu.AddItem( newItem,
+                                                           itemNextIndicator[i] ) )
+                            {
+                            // Too many or long menu items
+                            ret = KErrCorrupt;
+                            }
+                        }
+                    //menu item
+                    else
+                        {
+                        TInt retAdd = menu.AddItem( newItem );
+                        if ( KErrNoMemory == retAdd )
+                            {
+                            // Too many or long menu items
+                            // // If there is not enough space left in the
+                            // buffer used
+                            // by the menu KErrNoMemory is returned.
+                            ret = KErrCorrupt;
+                            // send terminal response
+                            iSatMessHandler->SetUpMenuTerminalResp(
+                                    iTransId,
+                                    iCommandDetails,
+                                    RSat::KCmdDataNotUnderstood,
+                                    RSat::KNoAdditionalInfo );
+                            }
+                        }
+                    }
+                itemNbr++;
+                returnValue = berTlv.TlvByTagValue( &itemsData,
+                                                        KTlvItemTag,
+                                                        itemNbr );
+                }
+            }
+        }
+    if ( iReqHandle )
+        {
+        RSat::TSetUpMenuV2& setUpMenuV2 = ( *iSetUpMenuV2Pckg )();
+        setUpMenuV2 = menu;
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SetUpMenu PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpMenu::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPMENU_NOTIFY, "CSatNotifySetUpMenu::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySetUpMenu::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    TInt ret( KErrNone );
+    iReqHandle = aReqHandle;
+    iSetUpMenuV2Pckg = static_cast< RSat::TSetUpMenuV2Pckg* >( aDataPtr );
+    ret = iSatMessaging->SatReady( KSetUpMenu );
+    if ( KErrNotFound == ret )
+        {
+        if ( iSatIsiMsg )
+            {
+            MessageReceived( TIsiReceiveC( iSatIsiMsg->Des() ) );
+            delete iSatIsiMsg;
+            iSatIsiMsg = NULL;
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::TerminalResponse
+// Handles a SetUpMenu terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySetUpMenu::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponse");
+    TInt ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSetUpMenuRspV1Pckg* aRspPckg =
+            reinterpret_cast<RSat::TSetUpMenuRspV1Pckg*>( aRsp );
+    RSat::TSetUpMenuRspV1& rspV1 = ( *aRspPckg ) ();
+
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Entity) error, additional info is needed
+    if ( RSat::KMeProblem == rspV1.iInfoType )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = static_cast<TUint8>( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+
+    if( RSat::KSuccess == rspV1.iGeneralResult && iItemsNextIndicatorRemoved )
+        {
+        TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved" );
+        rspV1.iGeneralResult = RSat::KPartialComprehension;
+        }
+    iItemsNextIndicatorRemoved = EFalse;
+
+    // Creating the info message
+    iSatMessHandler->SetUpMenuTerminalResp(
+        iTransId,                                   // Transaction id
+        iCommandDetails,                            // Command number
+        static_cast<TUint8>( rspV1.iGeneralResult ),  // Result
+        additionalInfo );                           // additional info
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpMenu::SatApplicationName
+// Return a reference to sat application name.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TDes16& CSatNotifySetUpMenu::SatApplicationName()
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_SATAPPLICATIONNAME, "CSatNotifySetUpMenu::SatApplicationName" );
+    if ( 0x0 == iToolKitName.Length() )
+        {
+        // Default toolkit name
+        iToolKitName.Copy( KSatToolkit );
+        }
+    return iToolKitName;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySelectItem::CSatNotifySelectItem
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySelectItem::CSatNotifySelectItem
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSelectItemV2Pckg( NULL ),
+        iItemNextIndicatorRemoved( EFalse )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::CSatNotifySelectItem" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
+        + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySelectItem::~CSatNotifySelectItem
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySelectItem::~CSatNotifySelectItem()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::~CSatNotifySelectItem" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySelectItem::MessageReceived
+// Handles a SelectItem proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySelectItem::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived" );
+    TFLOGSTRING("CSatNotifySelectItem::MessageReceived");
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    // Get command qualifier
+    TUint8 cmdQualifier(
+        commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->SelectItemTerminalResp(
+            iTransId,                       // Transaction id
+            iCommandDetails,                // Command details TLV
+            RSat::KMeUnableToProcessCmd,    // Result
+            KNoCause  );                    // Additional info
+        }
+    else
+        {
+         // Fill the select item structure
+         RSat::TSelectItemV2& selectItemV2 = ( *iSelectItemV2Pckg )();
+        // Store command number
+        selectItemV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        TPtrC8 sourceString; // Used in unicode conversions
+        // Alpha id string (optional)
+        selectItemV2.iAlphaId.iAlphaId.Zero();
+        CTlv alphaIdentifier;
+        TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier,
+                                                KTlvAlphaIdentifierTag ) );
+        // If alpha id string exist
+        if ( KErrNone == returnValue )
+            {
+            TUint16 alphaIdLength(
+                alphaIdentifier.GetLength() );
+           if ( alphaIdLength )
+                {
+                // Get the alpha id
+                sourceString.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+
+                // Convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceString ,
+                                         selectItemV2.iAlphaId.iAlphaId );
+                }
+            // Check alpha tag (id) status
+           if ( alphaIdLength )
+                {
+                // Alpha tag present
+                if ( selectItemV2.iAlphaId.iAlphaId.Length() )
+                    {
+                    selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+           }
+        // Alpha id not present
+        else
+            {
+            selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            }
+        // Help information
+        if ( KHelpAvailabilityMask & cmdQualifier )
+            {
+            // Help information available
+            selectItemV2.iHelp = RSat::EHelpAvailable;
+            }
+        else
+            {
+            // No help
+            selectItemV2.iHelp = RSat::ENoHelpAvailable;
+            }
+
+        // Presentation type
+        if ( KSelectItemPresentationTypeMask & cmdQualifier )
+            {
+            if ( KSelectItemChoiceOfNavigationMask & cmdQualifier )
+                {
+                // Presentation as a choice of navigation options
+                selectItemV2.iPresentationType = RSat::ENavigationOptions;
+                }
+            else
+                {
+                // Presentation as a choice of data values
+                selectItemV2.iPresentationType = RSat::EDataValues;
+                }
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \
+            Presentation type was not set.");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Presentation type was not set" );
+
+            selectItemV2.iPresentationType = RSat::ENotSpecified;
+            }
+        // Selection preference
+        if ( KSelectItemSelectUsingSoftKeyMask & cmdQualifier )
+            {
+            // Preference = soft key
+            selectItemV2.iPreference = RSat::ESoftKeyPreferred;
+            }
+        else
+            {
+            // Preference not set
+            selectItemV2.iPreference = RSat::ENoSelectionPreference;
+            }
+        // Default item id ( optional )
+        CTlv defaultItem;
+        returnValue = berTlv.TlvByTagValue( &defaultItem,
+                                            KTlvItemIdentifierTag );
+        if ( KErrNone == returnValue )
+            {
+            selectItemV2.iDefaultItemId =
+                defaultItem.GetShortInfo( ETLV_IdentifierOfItemChosen );
+            }
+        // Icon qualifier list ( optional )
+        // Each item of a list of items has an icon identifier coded on one
+        // byte. The length of the Items icon identifier list shall be the
+        // number of items of the list of items (X-1 shall be the number of
+        // items in the list). The order of each item icon identifier,
+        // shall reflect the order of the items in the list of items.
+        // Each icon identifier addresses a record
+        // in EFIMG as defined in TS 11.11
+        CTlv itemsIconIdentifierList;
+        TInt retValue( berTlv.TlvByTagValue( &itemsIconIdentifierList,
+                                             KTlvItemIconIdentifierListTag ) );
+        selectItemV2.iIconListQualifier = RSat::EIconQualifierNotSet;
+        TPtrC8 iconIdList;
+        if ( KErrNone == retValue )
+            {
+            TUint8 iconListQualifier( itemsIconIdentifierList.GetShortInfo(
+                ETLV_IconListQualifier ) );
+            // set iconIdList pointer
+            iconIdList.Set(
+                itemsIconIdentifierList.GetData( ETLV_IconIdentifierList ));
+            // The icon list qualifier indicates to the ME how
+            // the icons are to be used
+            if( iconListQualifier )
+                {
+                // icon is not self-explanatory, i.e. if displayed,
+                // it shall be displayed together with the item text
+                selectItemV2.iIconListQualifier = RSat::ENotSelfExplanatory;
+                }
+            else
+                {
+                // icon is self-explanatory, i.e. if displayed,
+                // it replaces the item text
+                selectItemV2.iIconListQualifier = RSat::ESelfExplanatory;
+                }
+            }
+        else if ( KErrNotFound == retValue )
+            {
+            selectItemV2.iIconListQualifier = RSat::ENoIconId;
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \
+            Return value not valid.");
+            OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Return value not valid." );
+
+            }
+
+        CTlv item;
+        // Get all items
+        returnValue = berTlv.TlvByTagValueMulti( &item, KTlvItemTag );
+        TPtrC8 itemData = item.Data();
+        TUint8 numberOfItemData( 0 );
+        TInt ind( 0 );
+        TUint16 tlvLength( 0 );
+        TInt currentTlv( 0 );
+        TInt i( 0 );
+        // Set numberOfItemData
+        for ( i = 0; i < itemData.Length(); i += TInt( tlvLength ) )
+            {
+            // First determine if the length of the TLV is
+            // coded with 1 or 2 bytes.
+            if ( KTwoByteLengthCoding == itemData[ind+1] )
+                {
+                // Length is coded with 2 bytes -> real length is in second
+                // byte first byte is 81 and it is "tag" for 2 byte length
+                // coding.
+                tlvLength =
+                    TUint16( itemData[ind + 2] + KTlvHeaderLength + 1 );
+                }
+            else
+                {
+                //TLV header bytes (2) must be added to total length
+                tlvLength = TUint16( itemData[ind + 1]  + KTlvHeaderLength );
+                }
+
+            currentTlv = itemData[ind]&KTagValueMask;
+
+            if ( KTlvItemTag == currentTlv )
+                {
+                numberOfItemData++;
+                }
+
+            ind += tlvLength;
+            }
+
+        // See if itemnextindicator is included ( optional )
+        CTlv nextIndicator;
+
+        returnValue = berTlv.TlvByTagValue( &nextIndicator,
+            KTlvItemsNextActionIndicatorTag );
+        TPtrC8 itemNextIndicator;
+        if ( KErrNone == returnValue )
+            {
+            TPtrC8 itemNextIndicatorTemp;
+            itemNextIndicatorTemp.Set(
+                nextIndicator.GetData( ETLV_ItemsNextActionIndicator ) );
+
+            //In case the number of items in this list does not match the number
+            //of items in the menu the Items Next Action Indicator list is ignored by ME
+            if( itemNextIndicatorTemp.Length() != numberOfItemData )
+                {
+                iItemNextIndicatorRemoved = ETrue;
+                }
+            else
+                {
+                itemNextIndicator.Set(itemNextIndicatorTemp);
+                }
+            }
+
+        // Filling up the menu items
+        RSat::TItem newItem;
+        // Set string length and pos
+        TUint8 stringLength( 0 );
+        TUint8  pos( 2 );
+        // Transfers menu items to EtelSat data structure
+        for ( i = 0; ( i < numberOfItemData ) && ( KErrNone == ret ); i++ )
+            {
+            // Check if two byte length coding is used
+            if ( itemData[pos - 1] == KTwoByteLengthCoding )
+                {
+                // Set new offset
+                pos++;
+                }
+            // Fill item if TLV contains real data, length < 0
+            if ( KZero < itemData[pos - 1] )
+                {
+                // Fill the newitem
+                newItem.iItemId = itemData[pos];
+                stringLength = itemData[pos - 1];
+                }
+            else
+                {
+                // No real ítem data in TLV
+                newItem.iItemId = 0;
+                stringLength = 0;
+                }
+
+            // Copying the string from 8-bit to 16-bit
+            if ( stringLength > RSat::KMenuItemMaxSize )
+                {
+                // String too long
+                ret = KErrCorrupt;
+                }
+            newItem.iItemString.Zero();
+            // ArabicCoding, GreekCoding and TurkishCoding have different
+            // coding method. There is a tag for each type of alphabet
+            // (resp. 80, 81 or 82) before the text, and there are base
+            // pointers used for expanding 1 byte to 2 bytes as required
+            // in UCS2
+            // Ref: 3gpp 11.11, Annex B
+
+            //Check if string present
+            if ( 0 < ( stringLength - 1 ) )
+                {
+                TBuf8<RSat::KTextStringMaxSize> itemText;
+                itemText = itemData.Mid( pos + 1, stringLength - 1 );
+
+                if ( ( itemText[0] == KUCS2ArabicCoding )
+                    || ( itemText[0] == KUCS2GreekCoding )
+                    || ( itemText[0] == KUCS2TurkishCoding ) )
+                    {
+                    TSatUtility::ConvertAlphaFieldsToUnicode( itemText,
+                    newItem.iItemString );
+                    }
+                else
+                    {
+                    // 8-bit format
+                    TSatUtility::ConvertSms7ToUnicode16( newItem.iItemString,
+                                                         itemText );
+                    }
+                }
+
+            if( NULL != iconIdList.Size()
+                && ( i < iconIdList.Length() ) )
+                {
+                if( ( NULL != itemNextIndicator.Size() )
+                    && ( i < itemNextIndicator.Length() ) )
+                    {
+                    // ADD ITEM WITH ITEM NEXT INDICATOR AND ICON IDENTIFIER
+                    if ( KErrNoMemory == selectItemV2.AddItem(
+                        newItem, itemNextIndicator[i], iconIdList[i] ) )
+                        {
+                        // Too many or long menu items
+                        ret = KErrCorrupt;
+                        }
+                    }
+                // ADD ITEM WITH ICON
+                else if ( KErrNoMemory == selectItemV2.AddItemIcon(
+                    newItem, iconIdList[i] ) )
+                    {
+                    // Too many or long menu items
+                    ret = KErrCorrupt;
+                    }
+                else
+                    {
+                    TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived,\
+                    Item with icon not valid.");
+                    OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Item with icon not valid." );
+                    }
+                }
+            else
+                {
+                if( ( NULL != itemNextIndicator.Size() )
+                    && ( i < itemNextIndicator.Length() ) )
+                    {
+                    // ADD ITEM WITH ITEM NEXT INDICATOR
+                    if ( KErrNoMemory == selectItemV2.AddItem(
+                        newItem, itemNextIndicator[i] ) )
+                        {
+                        // Too many or long menu items
+                        ret = KErrCorrupt;
+                        }
+                    }
+                //ADD ITEM
+                else
+                    {
+                    TInt retAdd = selectItemV2.AddItem( newItem );
+                    if ( KErrNoMemory == retAdd )
+                        {
+                        // Too many or long menu items
+                        // If there is not enough space left in the buffer used
+                        // by the menu KErrNoMemory is returned.
+                        // Send terminal response
+                        iSatMessHandler->SelectItemTerminalResp(
+                            iTransId,                        // transaction id
+                            iCommandDetails,                // Command details TLV
+                            RSat::KCmdDataNotUnderstood,    // Result
+                            KNoCause );                     // Additional info
+                        ret = KErrCorrupt;
+                        }
+                    }
+                }
+            // Calculating the new position
+            pos = TUint8( pos + itemData[pos - 1] + 2 );
+            }
+        // Iconid
+        TSatUtility::FillIconStructure( berTlv, selectItemV2.iIconId );
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySelectItem::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SelectItem PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySelectItem::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSELECTITEM_NOTIFY, "CSatNotifySelectItem::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySelectItem::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iSelectItemV2Pckg = static_cast< RSat::TSelectItemV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSelectItem );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySelectItem::TerminalResponse
+// Handles a SelectItem terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySelectItem::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySelectItem::TerminalResponse");
+    TInt   ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSelectItemRspV1Pckg* aRspPckg =
+            reinterpret_cast<RSat::TSelectItemRspV1Pckg*>( aRsp );
+    RSat::TSelectItemRspV1& rspV1 = ( *aRspPckg ) ();
+
+    // Check that general result values are valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    // If there is Me (Mobile Entity) error or there there should be
+    // item identifier or
+    // general result is success, additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType )
+        || ( RSat::KItemIdentifier == rspV1.iInfoType )
+        || ( RSat::KSuccess == rspV1.iGeneralResult ) )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = static_cast<TUint8>( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+
+    if( RSat::KSuccess == rspV1.iGeneralResult && iItemNextIndicatorRemoved )
+        {
+        TFLOGSTRING("CSatNotifySelectItem::TerminalResponseL, iItemNextIndicatorRemoved");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse, iItemNextIndicatorRemoved" );
+
+        rspV1.iGeneralResult = RSat::KPartialComprehension;
+        }
+    iItemNextIndicatorRemoved = EFalse;
+
+    iSatMessHandler->SelectItemTerminalResp(
+                                iTransId,                    // Transaction id
+                                iCommandDetails,            // Command details
+                                static_cast< TUint8 >(
+                                    rspV1.iGeneralResult ), // General result
+                                additionalInfo );           // Additional info
+    return ret;
+
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::CSatNotifySendSm
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendSm::CSatNotifySendSm
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSendSmV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::CSatNotifySendSm" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KNetworkUnableToProcessCmd + RSat::KSmsRpError
+        + RSat::KErrorRequiredValuesMissing
+        + RSat::KInteractionWithCCPermanentError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::~CSatNotifySendSm
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendSm::~CSatNotifySendSm()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::~CSatNotifySendSm" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::MessageReceived
+// Handles a SendSm proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendSm::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived" );
+    TFLOGSTRING("CSatNotifySendSm::MessageReceived");
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->SendSmTerminalResp(
+            iTransId,                       // Transaction id
+            iCommandDetails,                // Command details tlv
+            RSat::KMeUnableToProcessCmd,    // Result
+            KNoCause );                     // Additional info
+        }
+    else
+        {
+        // Fill the send sm structure
+        RSat::TSendSmV1& sendSmV1 = ( *iSendSmV1Pckg )();
+        // Store command number
+        sendSmV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        sendSmV1.iSmsTpdu.Zero();
+        CTlv smsTpduTlv;
+        // Get TPdu tlv
+        TInt returnValue( berTlv.TlvByTagValue( &smsTpduTlv,
+                                                KTlvSmsTpduTag ) );
+        if ( KErrNone == returnValue )
+            {
+            // Tpdu TLV length
+            TUint16 smsTpduLength( smsTpduTlv.GetLength() );
+            // Set pointer to Tpdu
+            TPtrC8 smsTpdu = smsTpduTlv.GetData( ETLV_SmsTPdu );
+            // Check that TP-UDL is valid
+            ret = CheckTpdu( smsTpdu );
+            if ( KErrCorrupt == ret )
+                {
+                // Length of TPDU is invalid
+                iSatMessHandler->SendSmTerminalResp(
+                         iTransId,                      // Transaction id
+                         iCommandDetails,               // Command details tlv
+                         RSat::KCmdDataNotUnderstood,   // Result
+                         KNoCause );                    // Additional info
+                }
+            if ( smsTpduLength && KErrNone == ret )
+                {
+                // Copying the smsTpdu
+                sendSmV1.iSmsTpdu.Append( smsTpdu );
+                }
+            // Checking if packing is required for the SMS message or not
+            // Packing: see ETSI 3.38 and 3.40
+            if ( KSmsPackingRequiredMask & iCommandDetails[KCommandQualifier]
+                && ( KErrNone == ret ) )
+                {
+                // Packing required
+                if ( smsTpduLength )
+                    {
+                    // Call method to pack sms
+                    ret = PackSms( smsTpdu, sendSmV1.iSmsTpdu );
+                    if ( KErrNone != ret )
+                        {
+                        // tpdu is invalid or packing cannot be requested
+                        // if tpdu is something else than SMS-SUBMIT
+                        iSatMessHandler->SendSmTerminalResp(
+                            iTransId,                   // Transaction id
+                            iCommandDetails,            // Command details tlv
+                            RSat::KCmdDataNotUnderstood,// Result
+                            KNoCause );                 // Additional info
+                        ret = KErrCorrupt;
+                        }
+                    }
+                }
+            }
+        else
+            {
+            // TPdu is missing, returning response immediately
+            iSatMessHandler->SendSmTerminalResp(
+                         iTransId,                      // Transaction id
+                         iCommandDetails,               // Command details tlv
+                         RSat::KErrorRequiredValuesMissing,// Result
+                         KNoCause );                    // Additional info
+            ret = KErrCorrupt;
+            }
+        if ( KErrNone == ret )
+            {
+            TPtrC8 sourceString; // Used in unicode conversions
+            // Alpha id string (optional)
+            sendSmV1.iAlphaId.iAlphaId.Zero();
+            CTlv alphaIdTlv;
+            returnValue = berTlv.TlvByTagValue( &alphaIdTlv,
+                                                KTlvAlphaIdentifierTag ) ;
+            if ( KErrNone == returnValue )
+                {
+                // alpha id tlv found
+                if ( alphaIdTlv.GetLength() )
+                    {
+                    // get alpha id text
+                    sourceString.Set(
+                        alphaIdTlv.GetData( ETLV_AlphaIdentifier ) );
+
+                    // convert and set alpha id
+                    TSatUtility::SetAlphaId( sourceString,
+                                             sendSmV1.iAlphaId.iAlphaId );
+                    }
+                // Alpha Tag present
+                if ( sendSmV1.iAlphaId.iAlphaId.Length() )
+                    {
+                    sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+            else
+                {
+                sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+                }
+            // The address data object holds the RP_Destination_Address of the
+            // Service Centre. If no RP_Destination_Address is transferred,
+            // then the ME shall insert the default Service Centre address.
+            // Service centre address
+            sendSmV1.iAddress.iTelNumber.Zero();
+            CTlv addressTlv;
+            // Get address tlv. Includes SCA number. (optional)
+            returnValue = berTlv.TlvByTagValue( &addressTlv, KTlvAddressTag );
+            if ( KErrNone == returnValue )
+                {
+                if ( 0 < addressTlv.GetLength() )
+                    {
+                    // Initialize ton and npi
+                    RSat::TTypeOfNumber ton;
+                    RSat::TNumberingPlan npi;
+                    // Call utility function that maps received TON and NPI to
+                    // RSat values
+                    TSatUtility::GetTonAndNpi(
+                        addressTlv.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi );
+                    // Set TON and NPI
+                    sendSmV1.iAddress.iTypeOfNumber = ton;
+                    sendSmV1.iAddress.iNumberPlan = npi;
+
+                    TBuf8<RSat::KMaxMobileTelNumberSize> tempScaNumber;
+                    // set pointer to address tlv
+                    sourceString.Set(
+                        addressTlv.GetData( ETLV_DiallingNumberString ) );
+                    if ( sourceString.Length() )
+                        {
+                        // Semi-octet presentation used
+                        // Converting back to ASCII format
+                        TSatUtility::BCDToAscii( sourceString, tempScaNumber );
+
+                        sendSmV1.iAddress.iTelNumber.Copy( tempScaNumber );
+
+                        TFLOGSTRING2("TSY:SendSm, SCA number: %S",
+                        &sendSmV1.iAddress.iTelNumber );
+                        OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived SCA number: %S", sendSmV1.iAddress.iTelNumber );
+                        }
+                    else
+                        {
+                        // Address TLV found, TON/NPI present, but number epmpty.
+                        sendSmV1.iAddress.iTypeOfNumber = RSat::EUnknownNumber;
+                        sendSmV1.iAddress.iNumberPlan = RSat::EUnknownNumberingPlan;
+                        }
+                    }
+                else
+                    {
+                    // Address TLV found, but the Value part doesn't exist
+                    sendSmV1.iAddress.iTypeOfNumber = RSat::EUnknownNumber;
+                    sendSmV1.iAddress.iNumberPlan = RSat::EUnknownNumberingPlan;
+                    }
+                }
+            else
+                {
+                // Addrress TLV not found
+                sendSmV1.iAddress.iTypeOfNumber = RSat::ETypeOfNumberNotSet;
+                sendSmV1.iAddress.iNumberPlan = RSat::ENumberingPlanNotSet;
+                }
+            // Iconid
+            TSatUtility::FillIconStructure( berTlv, sendSmV1.iIconId );
+            }
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SendSm PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendSm::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSM_NOTIFY, "CSatNotifySendSm::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySendSm::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+                aReqHandle );
+    iReqHandle = aReqHandle;
+    iSendSmV1Pckg = static_cast< RSat::TSendSmV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSendShortMessage );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::TerminalResponse
+// Handles a SendSm terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendSm::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_TERMINALRESPONSE, "CSatNotifySendSm::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySendSm::TerminalResponse");
+    TInt ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSendSmRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSendSmRspV1Pckg* >( aRsp );
+    RSat::TSendSmRspV1& rspV1 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Entity) error or network error, additional info
+    // is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType )
+        || ( RSat::KSatNetworkErrorInfo == rspV1.iInfoType )
+        || ( RSat::KControlInteraction == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( 0 == rspV1.iAdditionalInfo.Length() )
+            {
+            // No info
+            ret = KErrCorrupt;
+            }
+        else
+            {
+            additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] );
+            }
+        }
+    // Creating the info message
+    iSatMessHandler->SendSmTerminalResp(
+                        iTransId,                   // Transaction id
+                        iCommandDetails,            // Command details tlv
+                        static_cast< TUint8 >(
+                            rspV1.iGeneralResult ), // Result
+                        additionalInfo );           // Additional info
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::GetTpUdlIndex
+// Returns respectively index of TP-UDL or TP-CDL field if sms type is
+// respectively SMS-SUBMIT or SMS-COMMAND
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint8 CSatNotifySendSm::GetTpUdlIndex
+    (
+    TPtrC8 aTpdu // Tpdu where to read TP-UDL or TP-CDL
+    )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPUDLINDEX, "CSatNotifySendSm::GetTpUdlIndex" );
+    TFLOGSTRING("CSatNotifySendSm::GetTpUdlIndex");
+
+    // Position on TP-UDL/TP-CDL field in SMS TPDU
+    TUint8 tpDlIndex( 0 );
+
+    // SMS-SUBMIT
+    if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) )
+        {
+        // Add mandatory fields at first: TP-MTI, TP-MR, TP-DA(address length,
+        // TON&NPI), TP-PID, DCS and TP-UDL.
+        // Index starts from [0]
+        tpDlIndex = KTPDUMandatoryFieldsSmsSubmitUdl;
+
+        // Checking the TP-VP field existence and format
+        // bit4    bit3
+        // 0       0   TP-VP field not present
+        // 1       0   TP-VP field present - relative format
+        // 0       1   TP-VP field present - enhanced format
+        // 1       1   TP-VP field present - absolute format
+
+        // Shift by 3 and mask for getting bits 3 and 4
+        TUint8 vpFormat( ( aTpdu[0] >> 3 ) & KSmsVpFormatMask );
+
+        if ( KSmsVPFRelative == vpFormat )
+            {
+            // TP-Validity period comprises 1 octet
+            tpDlIndex++;
+            }
+        else if ( KSmsVPFEnhanced == vpFormat || KSmsVPFAbsolute == vpFormat )
+            {
+            // TP-Validity period comprises 7 octets
+            tpDlIndex += 7;
+            }
+
+        // Calculate the address length in bytes, located in index 2
+        TUint8 addressLengthInBytes( aTpdu[2] );
+        // Address length is number of BCD characters.
+        // Two BCD string chars are coded in one byte =>
+        // divide by two (shitf to right). Before dividing, 1 is added
+        // for ensuring that result is rounded up in case of odd value
+        addressLengthInBytes++;
+        addressLengthInBytes >>= 1;
+
+        // Add address length
+        tpDlIndex += addressLengthInBytes;
+        }
+    // SMS-COMMAND
+    else
+        {
+        // Add mandatory fields at first: TP-MTI, TP-MR, TP-PID, TP-CT, TP-MN,
+        // TP-DA(address length, TON&NPI) and TP-CDL.
+        // Index starts from [0]
+        tpDlIndex = KTPDUMandatoryFieldsSmsCommandUdl;
+        // Address length, located in index 5
+        TUint8 addressLengthInBytes( aTpdu[5] );
+        // Address length is number of BCD characters
+        // Two BCD string chars are coded in one byte =>
+        // divide by two (shitf to right). Before dividing, 1 is added
+        // for ensuring that result is rounded up in case of odd value
+        addressLengthInBytes++;
+        addressLengthInBytes >>= 1;
+
+        // Add address length
+        tpDlIndex += addressLengthInBytes;
+        }
+
+    return tpDlIndex; // Return TP-UDL/TP-CDL index
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::GetTpDcsIndex
+// Returns index of TP-DCS (data coding scheme) of the sms.
+// SMS type is SMS-SUBMIT.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint8 CSatNotifySendSm::GetTpDcsIndex
+        (
+        TPtrC8 aTpdu // Tpdu
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPDCSINDEX, "CSatNotifySendSm::GetTpDcsIndex" );
+    TFLOGSTRING("CSatNotifySendSm::GetTpDcsIndex");
+
+    // Position of TP-DCS field in SMS TPDU
+    // Add mandatory fields at first: TP-MTI, TP-MR, TP-DA(address length,
+    // TON/NPI), TP-PID and TP-DCS.
+    // Index starts from [0]
+    TUint8 tpDcsIndex( KTPDUMandatoryFieldsSmsSubmitDcs );
+    // Calculate the length of address, located in index 2
+    TUint8 addressLengthInBytes( aTpdu[2] );
+    // Address lenght is number of BCD characters.
+    // Add one for ensuring the rounding up after division in case of odd
+    // number
+    addressLengthInBytes++;
+    // Divide by two for getting length in bytes
+    addressLengthInBytes >>= 1;
+    // Add address length to dcs position
+    tpDcsIndex += addressLengthInBytes;
+
+    return tpDcsIndex; // Return index of TP-DCS
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::CheckTpdu
+// Check TPDU validity
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendSm::CheckTpdu
+        (
+        TPtrC8 aTpdu // TPDU
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu" );
+    TFLOGSTRING("CSatNotifySendSm::CheckTpdu");
+    TInt ret( KErrNone );
+    TUint8 tpUdlPos( 0 ); // UDL position
+    TUint8 tpUdl( 0 ); // User data length
+    TUint8 bufferLength( aTpdu.Length() ); // TPDU buffer length
+
+    // At first check that TPDU length isn't under minimum
+    if ( KMinSmsTpduLength > bufferLength )
+        {
+        TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid TPDU length");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid TPDU length" );
+        ret = KErrCorrupt;
+        }
+    else
+        {
+        // Get index of UDL field
+        tpUdlPos = GetTpUdlIndex( aTpdu );
+        // Check that UDL index is valid
+        if ( tpUdlPos < bufferLength )
+            {
+            // Get user data length in 8-bit characters (without packing)
+            tpUdl = aTpdu[tpUdlPos];
+            }
+        else
+            {
+            TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid UDL index");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid UDL index" );
+            ret = KErrCorrupt;
+            }
+        }
+
+    if ( KErrNone == ret )
+        {
+        // SMS-SUBMIT
+        if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) )
+            {
+            // Only user data bytes are remained
+            bufferLength -= ( tpUdlPos + 1 );
+            // Get index of TP-DCS field
+            TUint8 tpDcsPos( GetTpDcsIndex( aTpdu ) );
+            // Get data coding scheme
+            TUint8 dcs( aTpdu[tpDcsPos] );
+
+            // Bits 2 and 3 are for coding scheme ( spec. 3GPP TS23.038 )
+            dcs = ( dcs >> 2 ) & 0x03;
+            // GSM 7 bit default alphabet
+            if ( KSmsDcsDefaultAlphabet == dcs )
+                {
+                // When 7 bit packing is used, number of characters is calculated
+                // as follows (spec. 3GPP TS 23.038 V7.0.0 ):
+                // number of characters = length of user data in bytes * 8 / 7
+                bufferLength = ( bufferLength * 8 ) / 7;
+                // Check the validity of user data length
+                if ( KSmsMaxSize < tpUdl || bufferLength < tpUdl )
+                    {
+                    // Message is over 160 bytes or invalid user data length
+                    TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length");
+                    OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
+                    ret = KErrCorrupt;
+                    }
+                }
+            else // 8-bit or 16-bit data
+                {
+                // Check if packing is required
+                TBool isPackingRequired( KSmsPackingRequiredMask &
+                    iCommandDetails[KCommandQualifier] );
+                TUint8 maxSmsSize( isPackingRequired ?
+                    KSmsMaxSize : KSmsMaxSizeWithoutPacking );
+                // Check the validity of user data length
+                if ( maxSmsSize < tpUdl || bufferLength < tpUdl )
+                    {
+                    // Message size is over the limit or invalid user data length
+                    TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length");
+                    OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
+                    ret = KErrCorrupt;
+                    }
+                }
+            } // end of if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) )
+        else // SMS-COMMAND
+            {
+            if ( KSMSCommandMaxSize < tpUdl )
+                {
+                TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: user data length over maximum");
+                OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: user data length over maximum" );
+                ret = KErrCorrupt;
+                }
+            }
+        } // End of if ( KErrNone == ret )
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSm::PackSms
+// Pack SMS content if it is required by the sim
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendSm::PackSms
+        (
+        TPtrC8 aTpdu, // Received Tpdu
+        TTpdu& aSendSm // Where to store packed sms
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_PACKSMS, "CSatNotifySendSm::PackSms" );
+    TFLOGSTRING("CSatNotifySendSm::PackSms");
+    TInt ret( KErrNone );
+
+    // Checking the message type, SMS-SUBMIT can be packed:
+    //
+    // Bit1 | Bit0 | Message type
+    // ------------------------------------------------------------
+    //   0  |   0  | SMS-DELIVER (in the direction SC to MS)
+    //   0  |   0  | SMS-DELIVER REPORT (in the direction MS to SC)
+    //   1  |   0  | SMS-STATUS-REPORT (in the direction SC to MS)
+    //   1  |   0  | SMS-COMMAND (in the direction MS to SC)
+    //   0  |   1  | SMS-SUBMIT (in the direction MS to SC)
+    //   0  |   1  | SMS-SUBMIT-REPORT (in the direction SC to MS)
+    //   1  |   1  | Reserved
+    //
+    if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) )
+        {
+        // Message is a SMS-SUBMIT message.
+        //
+        // Get index of TP-UDL field and it is also starting position.
+        TUint8 startPosition( GetTpUdlIndex( aTpdu ) );
+        // Get number of characters what will be packed.
+        TUint8 charsToPack( aTpdu[startPosition] );
+        // Calculate end position.
+        TUint8 endPosition( startPosition + charsToPack );
+        // Get SMS TPDU length
+        TUint8 tpduLength( aTpdu.Length() );
+
+        // Initialize values.
+        TInt i( 0 );
+        TInt x( startPosition + 1 );
+        TBool endOfTPDU( EFalse );
+        TUint8 move( 0 );
+
+        // Lets pack all the characters in SMS Message (TP-UD), including header
+        // (TP-UD-Header) if exist.
+        //
+        // Go through the TP-UD.
+        for ( i = startPosition; i < endPosition; i++ )
+            {
+            // Check that index is not over SMS TPDU length.
+            if ( ( i + 1 ) < tpduLength )
+                {
+                TUint8 char1( TUint8( aTpdu[i + 1] >> move ) );
+
+                TUint8 char2( 0 );
+
+                if ( ( i + 2 ) <= endPosition )
+                    {
+                    // Check that index is not over SMS TPDU length.
+                    if ( ( i + 2 ) < tpduLength )
+                        {
+                        char2 = TUint8( aTpdu[i + 2] << ( 7 - move ) );
+                        }
+                    else
+                        {
+                        ret = KErrCorrupt;
+                        break;
+                        }
+                    }
+                else
+                    {
+                    // No more characters to pack.
+                    endOfTPDU = ETrue;
+                    char2 = 0;
+                    }
+
+                // Append packed characters.
+                aSendSm[x++] = TUint8( char1 | char2 );
+
+                // New values for next round.
+                if ( ( 6 == move ) && !endOfTPDU )
+                    {
+                    i++;
+                    move = 0;
+                    }
+                else
+                    {
+                    move++;
+                    }
+                }
+            else
+                {
+                ret = KErrCorrupt;
+                break;
+                }
+            }
+
+        // TP-UD is now packed
+        if ( KErrCorrupt != ret )
+            {
+            // New string length (number of characters)
+            //
+            // Calculate if string length is changed from orginal length.
+            // These lengths are aTpdu[] buffer length so it start from "0"
+            // > "i" includes old value
+            // > "x" is new value with packed TP-UD
+            // > "x - 1" because we needed to add one for start point earlier
+            //           to append characters to correct position.
+            TUint8 stringLengthChanged( i - ( x - 1 ) );
+
+            if ( stringLengthChanged )
+                {
+                aSendSm.SetLength( aSendSm.Length() - stringLengthChanged );
+                }
+
+            // Change the DCS to default alphabet coding. See ETSI 3.38
+            //
+            // Get the position of TP-DCS
+            TUint8 posDCS( GetTpDcsIndex( aTpdu ) );
+
+            // Coding Group Bits are 7..4 and Use of bits are 3..0
+            // We need to find out correct Coding Group.
+            //
+            // KMaskC0: 0xC0 = 1100 0000
+            // > This check include Coding Group:
+            // >> Bits:  7..4
+            // >> Group: 00xx
+            //
+            if ( KMask0 == ( aTpdu[posDCS] & KMaskC0 ) )
+                {
+                // Set bits 2 and 3 to 0.
+                // Bits 3 and 2 indicate the alphabet being used, as follows:
+                //
+                // Bit3 | Bit2 | Alphabet:
+                // ----------------------------------------
+                //   0  |   0  | GSM 7 bit default alphabet
+                //   0  |   1  | 8 bit data
+                //   1  |   0  | UCS2 (16bit)
+                //   1  |   1  | Reserved
+                //
+                // KMaskF3: 0xF3 = 1111 0011
+                aSendSm[posDCS] = TUint8( aSendSm[posDCS] & KMaskF3 );
+                }
+
+            // KMaskF0: 0xF0 = 1111 0000
+            // > This check include Coding Group:
+            // >> Bits:  7..4
+            // >> Group: 1111
+            //
+            if ( KMaskF0 == ( aTpdu[posDCS] & KMaskF0 ) )
+                {
+                // Set bit 2 to 0.
+                // Bit 3 is reserved, set to 0.
+                //
+                // Bit 2 indicate the alphabet being used, as follows:
+                //
+                // Bit2 | Message coding:
+                // ---------------------------------
+                //   0  | GSM 7 bit default alphabet
+                //   1  | 8-bit data
+                //
+                // KMaskFB: 0xFB = 1111 1011
+                aSendSm[posDCS] = TUint8( aSendSm[posDCS] & KMaskFB );
+                }
+            }
+        }
+    else
+        {
+        // Packing cannot be requested if TPDU is something else
+        // than SMS submit.
+        ret = KErrCorrupt;
+        }
+
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendDtmf::CSatNotifySendDtmf
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendDtmf::CSatNotifySendDtmf
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSendDtmfV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::CSatNotifySendDtmf" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendDtmf::~CSatNotifySendDtmf
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendDtmf::~CSatNotifySendDtmf()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::~CSatNotifySendDtmf" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendDtmf::MessageReceived
+// Handles a SendDtmf proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendDtmf::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_MESSAGERECEIVED, "CSatNotifySendDtmf::MessageReceived" );
+    TFLOGSTRING("CSatNotifySendDtmf::MessageReceived");
+    // get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        iSatMessHandler->SendDtmfTerminalResp( iTransId,
+                                                iCommandDetails,
+                                                RSat::KMeUnableToProcessCmd,
+                                                KNoCause );
+        }
+    else
+        {
+        TInt returnValue( KErrNone );
+        TInt ret( KErrNone );
+        // Fill the send ss structure
+        RSat::TSendDtmfV1& sendDtmfV1 = ( *iSendDtmfV1Pckg )();
+        // command number
+        sendDtmfV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+         // Alpha id string (optional)
+        sendDtmfV1.iAlphaId.iAlphaId.Zero();
+        CTlv alphaIdentifier;
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+            KTlvAlphaIdentifierTag );
+        // if alpha id string exist
+        if( KErrNone == returnValue )
+            {
+            TUint16 alphaIdLength = alphaIdentifier.GetLength();
+
+            if ( alphaIdLength > RSat::KAlphaIdMaxSize )
+                {
+                // String too long
+                iSatMessHandler->SendDtmfTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    RSat::KCmdBeyondMeCapabilities,
+                                    KNoCause );
+                ret = KErrCorrupt;
+                }
+            else if ( alphaIdLength )
+                {
+                TPtrC8 temp; // Used with Copy8to16
+                 // get the alpha id
+                temp.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( temp ,
+                    sendDtmfV1.iAlphaId.iAlphaId );
+
+                sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                }
+            else
+                {
+                 sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                }
+            }
+        // Alpha id not present
+        else
+            {
+            sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            }
+
+        // Dtmf string length, 8-bit string, mandatory
+        CTlv sendDtmf;
+        returnValue = berTlv.TlvByTagValue( &sendDtmf,
+            KTlvDtmfStringTag );
+        if ( KErrNone == returnValue )
+            {
+            TUint8 generalResult( RSat::KSuccess );
+            // length - 1 for string
+            TUint16 dtmfStringLength = TUint16( sendDtmf.GetLength() );
+
+            //If first byte of the dtmf string is 0xFF it means that dtmf string
+            //is empty and we have to return general result
+            if ( ( dtmfStringLength && ( sendDtmf.Data()[2] == 0xFF ) ) ||
+                !dtmfStringLength )
+                {
+                generalResult = RSat::KCmdDataNotUnderstood;
+                ret = KErrCorrupt;
+                }
+            else if( RSat::KDtmfStringMaxSize < dtmfStringLength )
+                {
+                generalResult = RSat::KCmdBeyondMeCapabilities;
+                ret = KErrCorrupt;
+                }
+            else
+                {
+                sendDtmfV1.iDtmfString.Append( sendDtmf.GetData( ETLV_DtmfString ) );
+                }
+
+            if( KErrCorrupt == ret )
+                {
+                // String too long
+                iSatMessHandler->SendDtmfTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    generalResult,
+                                    KNoCause );
+                }
+            }
+        else
+            {
+            iSatMessHandler->SendDtmfTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    RSat::KErrorRequiredValuesMissing,
+                                    KNoCause );
+            ret = KErrCorrupt;
+            }
+
+        // Iconid
+        if ( KErrNone == ret )
+            {
+            TSatUtility::FillIconStructure( berTlv,
+                sendDtmfV1.iIconId );
+            }
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendDtmf::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SendDtmf PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendDtmf::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDTMF_NOTIFY, "CSatNotifySendDtmf::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySendDtmf::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+                aReqHandle );
+    iReqHandle = aReqHandle;
+    iSendDtmfV1Pckg = static_cast< RSat::TSendDtmfV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSendDtmf );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendDtmf::TerminalResponse
+// Handles a SendDtmf terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendDtmf::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_TERMINALRESPONSE, "CSatNotifySendDtmf::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySendDtmf::TerminalResponse");
+    TInt ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSendDtmfRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSendDtmfRspV1Pckg* >( aRsp );
+    RSat::TSendDtmfRspV1& rspV1 = ( *aRspPckg ) ();
+
+    // Check that general result values are valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    if( RSat::KMeProblem == rspV1.iInfoType )
+        {
+        if ( rspV1.iAdditionalInfo.Length() )
+            {
+            additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    else
+        {
+        // Invalid additional info field
+        ret = KErrCorrupt;
+        }
+
+    // Creating the info message
+    ret = iSatMessHandler->SendDtmfTerminalResp( iTransId, iCommandDetails,
+        TUint8( rspV1.iGeneralResult ), additionalInfo );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::CSatNotifySendSs
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendSs::CSatNotifySendSs
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSendSsV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::CSatNotifySendSs" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser
+        + RSat::KNetworkUnableToProcessCmd
+        + RSat::KInteractionWithCCTemporaryError + RSat::KSsReturnError
+        + RSat::KErrorRequiredValuesMissing
+        + RSat::KInteractionWithCCPermanentError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::~CSatNotifySendSs
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendSs::~CSatNotifySendSs()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::~CSatNotifySendSs" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::MessageReceived
+// Handles a DisplayText proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendSs::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_MESSAGERECEIVED, "CSatNotifySendSs::MessageReceived" );
+    TFLOGSTRING("CSatNotifySendSs::MessageReceived");
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        TBuf8<1> noCause;
+        iSatMessHandler->SendSsTerminalResp( iTransId,
+                                              iCommandDetails,
+                                              RSat::KMeUnableToProcessCmd,
+                                              noCause );
+        }
+    else
+        {
+        // Fill the send ss structure
+        RSat::TSendSsV1& sendSsV1 = ( *iSendSsV1Pckg )();
+        // Store command number
+        sendSsV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        TPtrC8 sourceString; // Used with conversions
+         // Alpha id string (optional)
+        sendSsV1.iAlphaId.iAlphaId.Zero();
+        CTlv alphaIdentifier;
+        // Get alpha id tlv from berTlv
+        TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier,
+                                                KTlvAlphaIdentifierTag ) );
+        // if alpha id string exist
+        if ( KErrNone == returnValue )
+            {
+            if ( alphaIdentifier.GetLength() )
+                {
+                // 8-bit string to 16-bit string
+                sourceString.Set(
+                    alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+
+                // Convert and set the alpha id
+                TSatUtility::SetAlphaId(
+                    sourceString ,sendSsV1.iAlphaId.iAlphaId );
+                // Set alpha id status
+                sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                }
+            else
+                {
+                sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                }
+            }
+        // Alpha id not present
+        else
+            {
+            sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            }
+        // SS string Tlv
+        sendSsV1.iSsString.iSsString.Zero();
+        CTlv ssString;
+        // Get SS string tlv
+        returnValue = berTlv.TlvByTagValue( &ssString,
+                                            KTlvSsStringTag );
+        if ( KErrNone == returnValue )
+            {
+            // Initialize ton and npi
+            RSat::TTypeOfNumber ton;
+            RSat::TNumberingPlan npi;
+
+            iSatMessaging->SetTonNpi ( ssString.GetShortInfo( ETLV_TonAndNpi ) );
+
+            // Call utility function that maps received TON and NPI
+            // to RSat values
+            TSatUtility::GetTonAndNpi(
+                ssString.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi );
+            // Set TON and NPI
+            sendSsV1.iSsString.iTypeOfNumber = ton;
+            sendSsV1.iSsString.iNumberPlan = npi;
+            // Check length of SS string.
+            // BCD format = two digits "packed" in one characher
+            if ( ssString.GetLength() * 2 <= RSat::KStringMaxSize )
+                {
+                TBuf8<RSat::KStringMaxSize> tempString;
+                // Set pointer to the BCD SS string
+                sourceString.Set( ssString.GetData( ETLV_SsOrUssdString ) );
+                // Semi-octet presentation used
+                // Converting back to ASCII format
+                TSatUtility::BCDToAscii( sourceString, tempString );
+                // Set pointer to the ASCII string.
+                sourceString.Set( tempString );
+                sendSsV1.iSsString.iSsString.Append( tempString );
+                }
+            else
+                {
+                // SS string is too long
+                ret = KErrCorrupt;
+                }
+            if ( RSat::EInternationalNumber ==
+                sendSsV1.iSsString.iTypeOfNumber )
+                {
+                // Append '+' character if the string is for call forwarding
+                CheckCallForwarding( sourceString, sendSsV1.iSsString );
+                }
+            }
+        else
+            {
+            // Mandatory tlv is missing, returning response immediately
+            TBuf8<1> noCause;
+            iSatMessHandler->SendSsTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details TLV
+                RSat::KErrorRequiredValuesMissing,  // Result
+                noCause );                          // Additional info
+            ret = KErrCorrupt;
+            CompleteRequest( ret );
+            return;
+            }
+        if ( KErrCorrupt == CheckSsStringValidity( sourceString ) ||
+            KErrCorrupt == ret )
+            {
+            TBuf8<1> noCause;
+            iSatMessHandler->SendSsTerminalResp(
+                iTransId,                           // Transaction id
+                iCommandDetails,                    // Command details TLV
+                RSat::KCmdDataNotUnderstood,        // Result
+                noCause );                          // Additional info
+            ret = KErrCorrupt;
+            }
+
+        // Icon (optional)
+        TSatUtility::FillIconStructure( berTlv, sendSsV1.iIconId );
+        CompleteRequest( ret );
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+        // Notify NokiaTSY that next SS request is SAT originated
+        if ( KErrNone == ret )
+            {
+            TFLOGSTRING("TSY: Inform NokiaTSY SS request being SAT originated");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_MESSAGERECEIVED, "Inform NokiaTSY SS request being SAT originated" );
+            iSatMessaging->GetMessageRouter()->ExtFuncL(
+                ESatNotifyCallControlRequest,
+                NULL );
+            }
+#endif
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SendSs PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendSs::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSS_NOTIFY, "CSatNotifySendSs::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySendSs::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+                aReqHandle );
+    iReqHandle = aReqHandle;
+    iSendSsV1Pckg = static_cast< RSat::TSendSsV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSendSs );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::TerminalResponse
+// Handles a DisplayText terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendSs::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_TERMINALRESPONSE, "CSatNotifySendSs::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySendSs::TerminalResponse");
+
+    TInt ret( KErrNone );
+
+    // Buffer for additional information
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+
+    RSat::TSendSsRspV2Pckg* aRspPckg =
+            reinterpret_cast<RSat::TSendSsRspV2Pckg*>( aRsp );
+    RSat::TSendSsRspV2& rspV2 = ( *aRspPckg ) ();
+
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    // If no SS error, set additional info
+    if ( RSat::KSsReturnError != rspV2.iGeneralResult )
+        {
+        // iAdditionalInfo is 8-bit
+        additionalInfo.Copy( rspV2.iAdditionalInfo );
+
+        if ( RSat::KSendSsInfo == rspV2.iInfoType && additionalInfo.Length() )
+            {
+            // Remove operation code.
+            // SATUI appends iOperationCode to additional info.
+            // RMmCustomAPI::TSsAdditionalInfo iAddtionalInfo includes
+            // correct SS Return Result Operation code, so fisrt byte of
+            // additionalInfo is not needed.
+            additionalInfo.Delete( 0, 1 );
+            }
+        }
+    else
+        {
+        // SS error code, one byte
+        // For the general result "SS Return Error", it is mandatory for the ME
+        // to provide additional information. The first byte shall be the error
+        // value given in the Facility (Return result) information element
+        // returned by the network (as defined in TS 24.080).
+        if ( 2 <= rspV2.iAdditionalInfo.Length() )
+            {
+            additionalInfo.Append( rspV2.iAdditionalInfo[1] );
+            }
+        else
+            {
+            additionalInfo.Append( 0x00 );
+            }
+        }
+
+    // Creating the info message
+    iSatMessHandler->SendSsTerminalResp( iTransId,
+                                         iCommandDetails,
+                                         TUint8( rspV2.iGeneralResult ),
+                                          additionalInfo );
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::CheckCallForwarding
+// Check SS string if it is for call forwarding. If it is
+// append '+' character to pretending international number.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendSs::CheckCallForwarding
+        (
+        TPtrC8 aSource,                 // original string
+        RSat::TSsString& aSsString      // where to store modified string
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKCALLFORWARDING, "CSatNotifySendSs::CheckCallForwarding" );
+    TFLOGSTRING("CSatNotifySendSs::CheckCallForwarding");
+    _LIT8(KCFU,"*21*");    // Call forwarding unconditional (CFU)
+    _LIT8(KCFB,"*67*");    // Call forwarding on Mobile Subscriber Busy(CFB)
+    _LIT8(KCFNRy, "*61*"); // Call forwarding on No Reply (CFNRy)
+    _LIT8(KCFNRc, "*62*"); // Call forwarding on Mobile Subscriber Not
+                           // Reachable (CFNRc)
+    // Try to find call forwarding string
+    TInt pos( aSource.Find( KCFU ) );
+    if ( KErrNotFound == pos )
+        {
+        pos = aSource.Find( KCFB );
+        }
+    if ( KErrNotFound == pos )
+        {
+        pos = aSource.Find( KCFNRy );
+        }
+    if ( KErrNotFound == pos )
+        {
+        pos = aSource.Find( KCFNRc );
+        }
+    if ( KErrNotFound != pos )
+        {
+        // String is for call forwarding
+        aSsString.iSsString.Zero();
+        aSsString.iSsString.Append( aSource.Left( pos + 4 ) );
+        aSsString.iSsString.Append( KPlusMarkCharacterCode );
+        aSsString.iSsString.Append(
+            aSource.Right( aSource.Length() - ( pos + 4) ) );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendSs::CheckSsStringValidity
+// Checks validity of SS string.If string includes undefined SS
+// characters or length is zero then return KErrCorrupt.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendSs::CheckSsStringValidity
+        (
+        TPtrC8 aSsString
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKSSSTRINGVALIDITY, "CSatNotifySendSs::CheckSsStringValidity" );
+    TFLOGSTRING("CSatNotifySendSs::CheckSsStringValidity");
+    TInt ret( KErrNone );
+    if ( !aSsString.Length() )
+        {
+        // If length is zero
+        ret = KErrCorrupt;
+        }
+    _LIT8( KDtmf,            "p");
+    _LIT8( KWild,            "w");
+    _LIT8( KExpansionDigit,  ".");
+    // SS string can contain only digits, star '*' and dash '#' characters.
+    if ( KErrNotFound != aSsString.Find( KDtmf )
+        || KErrNotFound != aSsString.Find( KWild )
+        || KErrNotFound != aSsString.Find( KExpansionDigit ) )
+        {
+        // Incompatible character found
+        ret = KErrCorrupt;
+        }
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendUssd::CSatNotifySendUssd
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendUssd::CSatNotifySendUssd
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSendUssdV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::CSatNotifySendUssd" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser
+        + RSat::KNetworkUnableToProcessCmd
+        + RSat::KInteractionWithCCTemporaryError
+        + RSat::KErrorRequiredValuesMissing + RSat::KUssdReturnError
+        + RSat::KInteractionWithCCPermanentError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendUssd::~CSatNotifySendUssd
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendUssd::~CSatNotifySendUssd()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::~CSatNotifySendUssd" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendUssd::MessageReceived
+// Handles a SendUssd proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendUssd::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived" );
+    TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+    //get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        TUint8 noCause( 0 );
+        TBuf<1>  noTextString;
+        TUint8  paramNotSet( 0 );
+        iSatMessHandler->SendUssdTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    RSat::KMeUnableToProcessCmd,
+                                    noCause,
+                                    noTextString,
+                                    paramNotSet );
+        }
+    else
+        {
+        // Fill the Send Ussd structure
+        RSat::TSendUssdV1& sendUssdV1 = ( *iSendUssdV1Pckg )();
+        sendUssdV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        TPtrC8 sourceStr; // Used with Copy8to16 function
+        // Alpha id string (optional)
+        sendUssdV1.iAlphaId.iAlphaId.Zero();
+        CTlv alphaIdentifier;
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+            KTlvAlphaIdentifierTag );
+        if ( KErrNotFound != returnValue )
+            {
+            TUint16 alphaIdLength = alphaIdentifier.GetLength() ;
+            if ( RSat::KAlphaIdMaxSize < alphaIdLength )
+                {
+                // String too long
+                TUint8 noCause( 0 );
+                TBuf<1>  noTextString;
+                TUint8  paramNotSet( 0 );
+                iSatMessHandler->SendUssdTerminalResp( iTransId,
+                                iCommandDetails,
+                                RSat::KMeUnableToProcessCmd,
+                                noCause,
+                                noTextString,
+                                paramNotSet );
+                ret = KErrCorrupt;
+                }
+            else if ( alphaIdLength )
+                {
+                // get the alpha id
+                sourceStr.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceStr ,
+                    sendUssdV1.iAlphaId.iAlphaId );
+                }
+            // Check alpha id status
+            // Alpha Tag present
+            if ( sendUssdV1.iAlphaId.iAlphaId.Length() )
+                {
+                sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                }
+            else
+                {
+                sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                }
+            }
+        else
+            {
+            sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            }
+        // Ussd string (mandatory)
+        CTlv ussdTlv;
+        sendUssdV1.iUssdString.iUssdString.Zero();
+        returnValue = berTlv.TlvByTagValue( &ussdTlv,
+            KTlvUssdStringTag );
+        if ( KErrNone == returnValue )
+            {
+            // Get the data coding scheme from the ISI msg
+            // and set the corresponding ETel Sat data field.
+            // The DCS is coded as for Cell Broadcast.
+            sendUssdV1.iUssdString.iDcs =
+                ussdTlv.GetShortInfo( ETLV_DataCodingScheme );
+            // Decode DCS
+            TSmsDcs decodedDcs( ESmsUnknownOrReservedDcs );
+            decodedDcs = TSatUtility::DecodeCbsDcs( sendUssdV1.iUssdString.iDcs );
+            TPtrC8 ussdString = ussdTlv.GetData( ETLV_UssdString );
+            TUint16 ussdStringLengthInBytes = TUint16( ussdString.Length() );
+            if ( ( ( ESms16BitDcs==decodedDcs )
+                   && 2*RSat::KStringMaxSize<ussdStringLengthInBytes)
+               || ( ( ESms8BitDcs==decodedDcs )
+                  && RSat::KStringMaxSize<ussdStringLengthInBytes)
+               || ( ( ESms7BitDcs==decodedDcs )
+                  && RSat::KStringMaxSize<8*ussdStringLengthInBytes/7))
+                {
+                // The Ussd text string is too long.
+                TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
+                USSD String too long");
+                OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD String too long" );
+                ret = KErrCorrupt;
+                TUint8 noCause( 0 );
+                TBuf<1>  emptyTextString;
+                TUint8  paramNotSet( 0 );
+                iSatMessHandler->SendUssdTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    RSat::KCmdDataNotUnderstood,
+                                    noCause,
+                                    emptyTextString,
+                                    paramNotSet );
+                }
+            else
+                {
+                // Conversion to 16-bit following the DCS
+                switch ( decodedDcs )
+                    {
+                    case ESms7BitDcs:
+                        {
+                        TBuf8<RSat::KStringMaxSize> ussdString8;
+                        TSatUtility::Packed7to8Unpacked( ussdString,
+                            ussdString8 );
+                        TSatUtility::ConvertSms7ToUnicode16(
+                            sendUssdV1.iUssdString.iUssdString, ussdString8 );
+                        break;
+                        }
+                    case ESms8BitDcs:
+                        {
+                        TSatUtility::ConvertSms7ToUnicode16(
+                            sendUssdV1.iUssdString.iUssdString, ussdString );
+                        break;
+                        }
+                    case ESms16BitDcs:
+                        {
+                        TIsiUtility::CopyFromBigEndian( ussdString , sendUssdV1.iUssdString.iUssdString );
+                        break;
+                        }
+                    default:
+                        {
+                        TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
+                        USSD DCS has a reserved value");
+                        OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD DCS has a reserved value" );
+                        // the DCS has a reserved value
+                        ret = KErrCorrupt;
+                        TUint8 noCause( 0 );
+                        TBuf<1>  emptyTextString;
+                        TUint8  paramNotSet( 0 );
+                        iSatMessHandler->SendUssdTerminalResp( iTransId,
+                                            iCommandDetails,
+                                            RSat::KCmdDataNotUnderstood,
+                                            noCause,
+                                            emptyTextString,
+                                            paramNotSet );
+                        break;
+                        }
+                    }
+                }
+            }
+        else
+            {
+            TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
+            Mandatory field missing");
+            OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, Mandatory field missing" );
+            // Mandatory field missing
+            ret = KErrCorrupt;
+            TUint8 noCause( 0 );
+            TBuf<1>  noTextString;
+            TUint8  paramNotSet( 0 );
+            iSatMessHandler->SendUssdTerminalResp( iTransId,
+                                iCommandDetails,
+                                RSat::KErrorRequiredValuesMissing,
+                                noCause,
+                                noTextString,
+                                paramNotSet );
+            }
+        if ( KErrNone == ret )
+            {
+            // Iconid
+            TSatUtility::FillIconStructure( berTlv,
+                sendUssdV1.iIconId );
+            }
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendUssd::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SendUssd PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendUssd::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDUSSD_NOTIFY, "CSatNotifySendUssd::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("TSY:CSatNotifySendUssd::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+                aReqHandle );
+    iReqHandle = aReqHandle;
+    iSendUssdV1Pckg = static_cast< RSat::TSendUssdV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSendUssd );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendUssd::TerminalResponse
+// Handles a SendUssd terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendUssd::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse" );
+    TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse");
+    TInt ret( KErrNone );
+    RSat::TSendUssdRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSendUssdRspV1Pckg* >( aRsp );
+    RSat::TSendUssdRspV1& rspV1 = ( *aRspPckg ) ();
+    TUint8 additionalInfo( 0 );
+    // Check that general result values are valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Entity) error, network error or text string,
+    // additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType )
+        || ( RSat::KCallControlRequestedAction == rspV1.iInfoType )
+        || ( RSat::KSatNetworkErrorInfo == rspV1.iInfoType )
+        || ( RSat::KTextString == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info:
+        if ( 0 == rspV1.iAdditionalInfo.Length() )
+            {
+            // No info
+            TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \
+            AdditionalInfoType set, but no additional info available");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set, but no additional info available" );
+            ret = KErrCorrupt;
+            }
+        else if ( RSat::KTextString == rspV1.iInfoType )
+            {
+            // Text string - additional info for a
+            // successful GET INKEY, GET INPUT or SEND USSD.
+            // --> Not used by SAT Server when the command has been
+            // performed successfully, SAT Server uses the
+            // rspV1.iUssdString.iUssdString to return the USSD string
+            // sent by the network.
+            TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \
+            AdditionalInfoType set to TextString.");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set to TextString." );
+            }
+        else
+            {
+            // For the general result "USSD Return Error",
+            // the ME shall provide additional information.
+            // The first byte shall be the error value given in
+            // the Facility (Return result) information element
+            // returned by the network (as defined in TS 24.080 [10]).
+            // One further value is defined:
+            // -    '00' = No specific cause can be given.
+            additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+            }
+        }
+    // Creating the info message
+    iSatMessHandler->SendUssdTerminalResp( iTransId, iCommandDetails,
+                               TUint8( rspV1.iGeneralResult ),
+                               additionalInfo,
+                               rspV1.iUssdString.iUssdString,
+                               rspV1.iUssdString.iDcs );
+    return ret;
+
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::CSatNotifySetUpCall
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpCall::CSatNotifySetUpCall
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSetUpCallV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::CSatNotifySetUpCall" );
+    TFLOGSTRING( "TSY:CSatNotifySetUpCall::CSatNotifySetUpCall" );
+    iCallConnectedEvent.Zero();
+
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KModifiedByCallControl + RSat::KPSessionTerminatedByUser
+        + RSat::KUssdTransactionTerminatedByUser
+        + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser
+        + RSat::KCallClearedBeforeConnectionOrReleased
+        + RSat::KInteractionWithCCTemporaryError + RSat::KSsReturnError
+        + RSat::KErrorRequiredValuesMissing
+        + RSat::KInteractionWithCCPermanentError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::~CSatNotifySetUpCall
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpCall::~CSatNotifySetUpCall()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::~CSatNotifySetUpCall" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::MessageReceived
+// Handles a SetUpCall proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpCall::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived" );
+    TFLOGSTRING("CSatNotifySetUpCall::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->SetUpCallTerminalResp( iTransId,
+                                                 iCommandDetails,
+                                                 RSat::KMeUnableToProcessCmd,
+                                                 KNoCause );
+        }
+    else
+        {
+        // Fill the Set Up Call structure
+        RSat::TSetUpCallV1& setUpCallV1 = ( *iSetUpCallV1Pckg )();
+        // Store command number
+        setUpCallV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+       switch ( iCommandDetails[KCommandQualifier] )
+            {
+            case KOnlyIfNotBusy:
+                {
+                // Set up call, if not busy on another call
+                setUpCallV1.iType = RSat::EOnlyIfNotBusy;
+                break;
+                }
+            case KOnlyIfNotBusyWithRedial:
+                {
+                // Set up call, if not busy on another call, with redial
+                setUpCallV1.iType = RSat::EOnlyIfNotBusyWithRedial;
+                break;
+                }
+            case KHoldOtherCalls:
+                {
+                // Set up call, put other calls (if any) on hold
+                setUpCallV1.iType = RSat::EHoldOtherCalls;
+                break;
+                }
+            case KHoldOtherCallsWithRedial:
+                {
+                // Set up call, put other calls (if any) on hold, with redial
+                setUpCallV1.iType = RSat::EHoldOtherCallsWithRedial;
+                break;
+                }
+            case KDisconnectOtherCalls:
+                {
+                // Set up call, disconnect other calls (if any)
+                setUpCallV1.iType = RSat::EDisconnectOtherCalls;
+                break;
+                }
+            case KDisconnectOtherCallsWithRedial:
+                {
+                // Set up call, disconnect other calls (if any), with redial
+                setUpCallV1.iType = RSat::EDisconnectOtherCallsWithRedial;
+                break;
+                }
+            default:
+                {
+                // Call type not set
+                setUpCallV1.iType = RSat::ESetUpCallTypeNotSet;
+                break;
+                }
+            }
+        TPtrC8 sourceString; // Used with conversions
+        // Alpha id string (optional)
+        setUpCallV1.iAlphaIdConfirmationPhase.iAlphaId.Zero();
+         // Call setup phase alphaid (optional)
+        setUpCallV1.iAlphaIdCallSetUpPhase.iAlphaId.Zero();
+        CTlv alphaIdentifier;
+        // check alpha identifiers (for user confirmation phase and call set
+        // up phase )
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+                                            KTlvAlphaIdentifierTag );
+        // if alpha id string exist
+        if ( KErrNone == returnValue )
+            {
+            // fist alpha identifier is for user confirmation phase
+            if ( alphaIdentifier.GetLength() )
+                {
+                // set status
+                setUpCallV1.iAlphaIdConfirmationPhase.iStatus =
+                    RSat::EAlphaIdProvided;
+
+                 // get alpha id string
+                sourceString.Set( alphaIdentifier.GetData(
+                    ETLV_AlphaIdentifier ) );
+
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceString ,
+                    setUpCallV1.iAlphaIdConfirmationPhase.iAlphaId );
+
+                }
+            // alpha id found for user confirmation phase, but length
+            // is zero
+            else
+                {
+                setUpCallV1.iAlphaIdConfirmationPhase.iStatus =
+                    RSat::EAlphaIdNull;
+                }
+            }
+        // no alpha id for user confirmation phase
+        else
+            {
+            setUpCallV1.iAlphaIdConfirmationPhase.iStatus =
+                RSat::EAlphaIdNotPresent;
+            }
+        // Get alpha identifier for call set up phase
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+                                            KTlvAlphaIdentifierTag, 1 );
+        // if alpha id string exist
+        if ( KErrNone == returnValue )
+            {
+            //second alpha identifier is for call set up phase
+            if ( alphaIdentifier.GetLength() )
+                {
+                // set status
+                setUpCallV1.iAlphaIdCallSetUpPhase.iStatus =
+                    RSat::EAlphaIdProvided;
+                 // get alpha id string
+                sourceString.Set( alphaIdentifier.GetData(
+                    ETLV_AlphaIdentifier ) );
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceString,
+                    setUpCallV1.iAlphaIdCallSetUpPhase.iAlphaId );
+
+                }
+            // alpha id found for set up call phase,  but length is zero
+            else
+                {
+                setUpCallV1.iAlphaIdCallSetUpPhase.iStatus =
+                    RSat::EAlphaIdNull;
+                }
+            }
+        // no alpha id set up call phase
+        else
+            {
+            setUpCallV1.iAlphaIdCallSetUpPhase.iStatus =
+                RSat::EAlphaIdNotPresent;
+            }
+        // First icon for user confirmation phase
+        TSatUtility::FillIconStructure(
+            berTlv, setUpCallV1.iIconIdConfirmationPhase, 0 );
+        // Second icon for set up call phase
+        TSatUtility::FillIconStructure(
+            berTlv, setUpCallV1.iIconIdCallSetUpPhase, 1 );
+        // Expecting address
+        CTlv addressTlv;
+        returnValue = berTlv.TlvByTagValue( &addressTlv,
+                                            KTlvAddressTag );
+        if ( KErrNone == returnValue && addressTlv.GetLength() )
+            {
+            // Initialize ton and npi
+            RSat::TTypeOfNumber ton( RSat::EUnknownNumber );
+            RSat::TNumberingPlan npi( RSat::EUnknownNumberingPlan );
+            // Call utility function that maps received TON and NPI to
+            // RSat values
+            TSatUtility::GetTonAndNpi(
+                addressTlv.GetShortInfo( ETLV_TonAndNpi ) , &ton, &npi );
+            // Set TON and NPI
+            setUpCallV1.iAddress.iTypeOfNumber = ton;
+            setUpCallV1.iAddress.iNumberPlan = npi;
+            // Address
+            setUpCallV1.iAddress.iTelNumber.Zero();
+            // length is number of BCD characters,
+            // multiply by two to get real length and - 2 for ton&npi
+            TInt dialNumberLength( ( ( addressTlv.GetLength() * 2 ) - 2 ) );
+
+           if ( dialNumberLength )
+                {
+                // Semi-octet presentation used
+                sourceString.Set(
+                    addressTlv.GetData( ETLV_DiallingNumberString ) );
+                TBuf8<RSat::KMaxMobileTelNumberSize> tempNumber;
+                // Convert BCD string to ascii
+                TSatUtility::BCDToAscii( sourceString, tempNumber );
+                sourceString.Set( tempNumber );
+                //add '+' character to the preceding of international number
+                if ( ( setUpCallV1.iAddress.iTypeOfNumber
+                    == RSat::EInternationalNumber )
+                        && (sourceString[0] != KPlusMarkCharacterCode )
+                        && RSat::KMaxMobileTelNumberSize > dialNumberLength )
+                    {
+                    _LIT8( KPlusMark, "+");
+                    tempNumber.Insert( 0, KPlusMark );
+                    sourceString.Set( tempNumber );
+                    }
+                // The command may also include DTMF digits, which the ME shall
+                // send to the network after the call has connected.
+                // Remove expansion digits from it if present.
+                TSatUtility::RemoveExpansionDigit( tempNumber );
+                // Set actual number
+                setUpCallV1.iAddress.iTelNumber.Copy( tempNumber );
+                TFLOGSTRING2("TSY: SetUpCall, TelNumber: %S",
+                &setUpCallV1.iAddress.iTelNumber );
+                OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived TelNumber: %S", setUpCallV1.iAddress.iTelNumber );
+                }
+            }
+        else
+            {
+            // address is missing, returning response immediately
+            iSatMessHandler->SetUpCallTerminalResp( iTransId,
+                                    iCommandDetails,
+                                    RSat::KCmdDataNotUnderstood,
+                                    KNoCause );
+            ret = KErrCorrupt;
+            }
+        // Bearer capability
+        setUpCallV1.iCapabilityConfigParams.Zero();
+        CTlv capabilityConfig;
+        returnValue = berTlv.TlvByTagValue( &capabilityConfig,
+            KTlvCapabilityConfigurationParametersTag );
+        if ( ( KErrNone == returnValue )
+            && ( capabilityConfig.GetLength() ) )
+            {
+            // iCapabilityConfigParams is 8-bit string
+            setUpCallV1.iCapabilityConfigParams.Append( capabilityConfig.
+                GetData( ETLV_CapabilityConfigurationParameters ) );
+            }
+        // Called Party SubAddress
+        setUpCallV1.iSubAddress.Zero();
+        CTlv subAddress;
+        returnValue = berTlv.TlvByTagValue( &subAddress, KTlvSubaddressTag );
+        if ( KErrNone == returnValue )
+            {
+            if ( subAddress.GetLength()
+                || subAddress.GetComprehensionRequired() )
+                {
+                TFLOGSTRING("TSY: SetUpCall, SubAddress is not supported!" );
+                OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "SetUpCall, SubAddress is not supported!" );
+                iSatMessHandler->SetUpCallTerminalResp( iTransId,
+                                        iCommandDetails,
+                                        RSat::KCmdBeyondMeCapabilities,
+                                        KNoCause );
+                ret = KErrCorrupt;
+                }
+            }
+
+        // Duration (optional, maximum duration for the redial mechanism)
+        TSatUtility::FillDurationStructure(
+            berTlv, setUpCallV1.iDuration );
+
+        // Set SetUpCall flag on for Call connected event. To avoid situation
+        // that event is send before terminal response
+        if ( KErrNone == ret )
+            {
+            iSatMessaging->SetSetUpCallStatus( ETrue );
+            }
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SetUpCall PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpCall::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_NOTIFY, "CSatNotifySetUpCall::Notify" );
+    TFLOGSTRING("CSatNotifySetUpCall::Notify");
+    iReqHandle = aReqHandle;
+    iSetUpCallV1Pckg = static_cast< RSat::TSetUpCallV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSetUpCall );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::TerminalResponse
+// Handles a SetUpCall terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySetUpCall::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_TERMINALRESPONSE, "CSatNotifySetUpCall::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySetUpCall::TerminalResponse");
+    TInt    ret( KErrNone );
+    TUint8  additionalInfo( 0 );
+    RSat::TSetUpCallRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSetUpCallRspV2Pckg* >( aRsp );
+    RSat::TSetUpCallRspV2& rspV2 = ( *aRspPckg ) ();
+
+    // Check that general result values are valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    // If there is Me (Mobile Entity) error or network error,
+    // additional info is needed
+    if ( ( RSat::KSatNetworkErrorInfo == rspV2.iInfoType )
+        || ( RSat::KMeProblem == rspV2.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( rspV2.iAdditionalInfo.Length() )
+            {
+            additionalInfo = static_cast<TUint8>( rspV2.iAdditionalInfo[0] );
+            }
+        else
+            {
+             // No info
+            ret = KErrCorrupt;
+            }
+        }
+
+    // Creating the terminal response message
+    iSatMessHandler->SetUpCallTerminalResp( iTransId,
+        iCommandDetails, TUint8( rspV2.iGeneralResult ), additionalInfo );
+
+    // Clear flag
+    iSatMessaging->SetSetUpCallStatus( EFalse );
+
+    // In the case of a call initiated through a SET UP CALL proactive command
+    // while the call connected event is part of the current event list, the
+    // ME shall send both the TERMINAL RESPONSE related to the proactive
+    // command, and the EVENT DOWNLOAD command, in the order TERMINAL RESPONSE
+    // first, ENVELOPE(EVENT DOWNLOAD - call connected) second.
+    // Check if there is stored envelope in the buffer
+    if ( iCallConnectedEvent.Length() )
+        {
+        // Send envelope..
+        iSatMessHandler->UiccCatReqEnvelope( iSatMessaging->GetTransactionId(),
+                                             iCallConnectedEvent );
+        // ..and clear the buffer
+        iCallConnectedEvent.Zero();
+        }
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpCall::StoreCallConnectedEvent
+// Store a Call connected envelope to buffer
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpCall::StoreCallConnectedEvent
+        (
+        const TDesC8& aEnvelope // envelope received from CSatEventDownload
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_STORECALLCONNECTEDEVENT, "CSatNotifySetUpCall::StoreCallConnectedEvent" );
+    // store it to the buffer
+    iCallConnectedEvent = aEnvelope;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::CSatNotifyRefresh
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyRefresh::CSatNotifyRefresh
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iRefreshV2Pckg( NULL ),
+        iRefreshRequiredV2Pckg( NULL ),
+        iReqHandleRefreshRequired( NULL ),
+        iInternalCache( KZero )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::CSatNotifyRefresh" );
+    iFileList.Zero();
+    iAid.Zero();
+
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KRefreshAdditionEFRead
+        + RSat::KRefreshUSIMNotActive + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::~CSatNotifyRefresh
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyRefresh::~CSatNotifyRefresh()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::~CSatNotifyRefresh" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::MessageReceived
+// Handles a Refresh proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyRefresh::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived");
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+     // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv. Returned to SIM card in terminal resp.
+    iCommandDetails.Copy( commandDetails.Data() );
+    // Store Transaction id
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle || !iReqHandleRefreshRequired )
+        {
+        TFLOGSTRING3("TSY: CSatNotifyRefresh::MessageReceived, iReqHandle:%d,\
+        iReqHandleRefreshRequired:%d ", iReqHandle, iReqHandleRefreshRequired );
+        OstTraceExt2( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived iReqHandle: %u, iReqHandleRefreshRequired: %u", iReqHandle, iReqHandleRefreshRequired );
+
+        // Some of the request were not on, returning response immediately
+        iSatMessHandler->RefreshTerminalResp(
+            iTransId,                       // Transaction id
+            iCommandDetails,                // Command details tlv
+            RSat::KMeUnableToProcessCmd,    // Result
+            RSat::KNoSpecificMeProblem );   // Additional info
+        }
+    else
+        {
+        // Fill the refresh structure
+        RSat::TRefreshV2& refreshV2 = ( *iRefreshRequiredV2Pckg )();
+        TInt returnValue( KErrNone );
+        // Is the command valid
+        TInt ret( KErrNone );
+         // File list
+        refreshV2.iFileList.Zero();
+        iFileList.Zero();
+        iInternalCache = 0;
+
+        CTlv fileListTlv;
+        returnValue = berTlv.TlvByTagValue( &fileListTlv,
+                                            KTlvFileListTag );
+        if ( KErrNone == returnValue )
+            {
+            // Filelist found
+            // Check if file list really contains any files
+            if ( KZero < fileListTlv.GetLength() )
+                {
+                // File list length, -1 for number of files
+                TUint8 fileLength( TUint8( fileListTlv.GetLength() - 1 ) );
+                // Save file list with full path.
+                // Needed when creating a SIM_ATK_REQ isi-message
+                iFileList = fileListTlv.GetData( ETLV_Files );
+                // Going through all files
+                // Received as 8-bit, append to 16-bit
+                TInt i( 0 );
+                for ( i = 0; i < fileLength / 2; i++ )
+                    {
+                    TUint16 oneItem( 0 );
+                    // read 16-bit
+                    TSatUtility::GetWord( oneItem, iFileList, 2 * i );
+                    // File header 8-bit
+                    TUint8 header( oneItem >> 8 );
+                    // The TSY needs to strip the Refresh File List
+                    // provided by the ICC to remove the paths to the files.
+                    //'3FXX': Master File;
+                    //'7FXX': 1st level Dedicated File;
+                    //'5FXX': 2nd level Dedicated File;
+                    if ( ( KRefreshMasterFileHeader != header )
+                        && ( KRefresh1StLevelDedicatedFileHeader != header )
+                        && ( KRefresh2StLevelDedicatedFileHeader != header ) )
+                        {
+                        // Append file to the file list, without path
+                        refreshV2.iFileList.Append( oneItem );
+                        }
+                    }
+                // Check if the file list contains the EF-SST file which is
+                // cached in SIM ATK TSY
+                if ( KErrNotFound != refreshV2.iFileList.Locate( RSat::KSstEf ) )
+                    {
+                    iInternalCache |= KCacheEFSST;
+                    }
+                // Check EF-CBMID
+                if ( KErrNotFound != refreshV2.iFileList.Locate( RSat::KCbmidEf ) )
+                    {
+                    iInternalCache |= KCacheEFCBMID;
+                    }
+                }
+            }
+        else if ( iCommandDetails[KCommandQualifier] ==
+                KFileChangeNotification )
+            {
+            // File list object is missing, return terminal resp immediately.
+            ret = KErrCorrupt;
+            iSatMessHandler->RefreshTerminalResp( iTransId,
+                                                   iCommandDetails,
+                                                   RSat::KErrorRequiredValuesMissing,
+                                                   RSat::KNoSpecificMeProblem );
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived, \
+            Return value of file list TLV not valid.");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Return value of file list TLV not valid." );
+            }
+        if ( KErrNone == ret )
+            {
+            // Set refresh mode
+            switch ( iCommandDetails[KCommandQualifier] )
+                {
+                case KSimInitFullFileChangeNotification:
+                    {
+                    TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \
+                    full file change notification");
+                    OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and full file change notification" );
+                    refreshV2.iType = RSat::ESimInitFullFileChangeNotification;
+                    iInternalCache = KCacheEFSST + KCacheEFCBMID;
+                    break;
+                    }
+                case KFileChangeNotification:
+                    {
+                    TFLOGSTRING("TSY: SAT, refresh mode: File Change \
+                    Notification");
+                    TFLOGSTRING2("TSY: Number of files: %d",
+                    refreshV2.iFileList.Length() );
+
+                    OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: File Change Notification" );
+                    OstTrace1( TRACE_NORMAL, DUP5_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
+
+                    refreshV2.iType = RSat::EFileChangeNotification;
+                    if ( KErrNotFound !=
+                        refreshV2.iFileList.Locate( RSat::KImsiEf )
+                            && !fileListTlv.GetComprehensionRequired() )
+                        {
+                        // IMSI was part of file list and the CR bit was cleared
+                        // This is done here because client does not have the CR
+                        // bit information available,
+                        // Other error values comes from Client
+                        ret = KErrCorrupt;
+                        iSatMessHandler->RefreshTerminalResp( iTransId,
+                            iCommandDetails,
+                            RSat::KErrorRequiredValuesMissing,
+                            RSat::KNoSpecificMeProblem );
+                        }
+                    break;
+                    }
+                case KSimInitFileChangeNotification:
+                    {
+                    TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \
+                    file change notification");
+                    TFLOGSTRING2("TSY: Number of files: %d",
+                    refreshV2.iFileList.Length() );
+
+                    OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and file change notification" );
+                    OstTrace1( TRACE_NORMAL, DUP7_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
+
+                    refreshV2.iType = RSat::ESimInitFileChangeNotification;
+                    break;
+                    }
+                case KSimInit:
+                    {
+                    TFLOGSTRING("TSY: SAT, Refresh mode: Sim init ");
+                    OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init" );
+                    refreshV2.iType = RSat::ESimInit;
+                    iInternalCache = KCacheEFSST + KCacheEFCBMID;
+                    break;
+                    }
+                case KSimReset:
+                    {
+                    refreshV2.iType = RSat::ESimReset;
+                    TFLOGSTRING("TSY: SAT, Refresh mode: Reset");
+                    OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Reset" );
+                    iInternalCache = KCacheEFSST + KCacheEFCBMID;
+                    break;
+                    }
+                case KUSIMApplicationReset:
+                    {
+                    TFLOGSTRING("TSY: SAT, Refresh mode: USIM Application Reset");
+                    OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: USIM Application Reset" );
+                    refreshV2.iType = RSat::EUsimApplicationReset;
+                    iInternalCache = KCacheEFSST + KCacheEFCBMID;
+                    break;
+                    }
+                case K3GSessionReset:
+                    {
+                    TFLOGSTRING("TSY: SAT, Refresh mode: 3G Session Reset");
+                    OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: 3G Session Reset" );
+                    refreshV2.iType = RSat::E3GSessionReset;
+                    break;
+                    }
+                default:
+                    // This migth be an error case
+                    refreshV2.iType = RSat::ERefreshTypeNotSet;
+                    break;
+                }
+            // Application identifies(optional)
+            // If an AID TLV is present, it indicates the USIM application which
+            // needs to be refreshed. If it is not present, the ME shall assume
+            // the current USIM application needs to be refreshed.
+            CTlv applicationId;
+            returnValue = berTlv.TlvByTagValue( &applicationId, KTlvAIDTag );
+            iAid.Zero();
+            if ( KErrNone == returnValue )
+                {
+                // Set application identifies
+                refreshV2.iAid = applicationId.GetData( ETLV_AID );
+                // Store aplication Id to member variable.
+                iAid = refreshV2.iAid;
+                }
+            }
+        // Copy parameters
+        (*iRefreshV2Pckg)() = ( *iRefreshRequiredV2Pckg )();
+        TTsyReqHandle tempReqHandle = iReqHandleRefreshRequired;
+        iReqHandleRefreshRequired = NULL;
+        // Ask permission from client
+        iSatMessaging->ReqCompleted( tempReqHandle, ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a Refresh PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyRefresh::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFY, "CSatNotifyRefresh::Notify" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::Notify");
+    iReqHandle = aReqHandle;
+    iRefreshV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr );
+    if ( iReqHandleRefreshRequired )
+        {
+        // Check the command buffer, if both notifications are received
+        iSatMessaging->SatReady( KRefresh );
+        }
+
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::NotifyRefreshRequired
+// Notification requested by ETel server
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyRefresh::NotifyRefreshRequired
+        (
+        const TTsyReqHandle aReqHandle,  // Request handle
+        TDes8*              aDataPtr     // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFYREFRESHREQUIRED, "CSatNotifyRefresh::NotifyRefreshRequired" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::NotifyRefreshRequired");
+    iReqHandleRefreshRequired = aReqHandle;
+    iRefreshRequiredV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr );
+    if ( iReqHandle )
+        {
+        // Check the command buffer, if both notifications are received
+        iSatMessaging->SatReady( KRefresh );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::CancelRefreshRequiredNotification
+// Cancels the current notification request
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyRefresh::CancelRefreshRequiredNotification
+        (
+        const TTsyReqHandle aReqHandle  // Request handle
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CANCELREFRESHREQUIREDNOTIFICATION, "CSatNotifyRefresh::CancelRefreshRequiredNotification" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::CancelRefreshRequiredNotification");
+    // Check that the handle is valid
+    if ( aReqHandle == iReqHandleRefreshRequired )
+        {
+        iSatMessaging->ReqCompleted( aReqHandle, KErrCancel );
+        }
+    else
+        {
+        // Handle is not valid
+        iSatMessaging->ReqCompleted( aReqHandle, KErrCorrupt );
+        }
+    iReqHandleRefreshRequired = NULL;
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::TerminalResponse
+// Handles a Refresh terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyRefresh::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse");
+    RSat::TRefreshRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aRsp );
+    RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) ();
+    TUint8 additionalInfo( 0x00 );
+    if ( RSat::KNoAdditionalInfo != rspV1.iInfoType )
+        {
+        additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+        }
+
+    // Empty TR is sent to Simson, if refresh type was Reset or IMSI was
+    // changed during the SIM Init refresh. Empty TR is not sent to SIM,
+    if ( KSimReset == iCommandDetails[KCommandQualifier] )
+        {
+        TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR" );
+        TBuf8<1> emptyDescriptor( KNullDesC8 );
+        iSatMessHandler->UiccCatReqTerminalResponse(
+            emptyDescriptor, emptyDescriptor, iTransId );
+        }
+    else
+        {
+        TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" );
+        OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" );
+        // Send terminal response
+        iSatMessHandler->RefreshTerminalResp(
+                        iTransId,                        // Transaction id
+                        iCommandDetails,                 // Command number
+                        TUint8 ( rspV1.iGeneralResult ), // Result
+                        additionalInfo );                // Additinal info
+        }
+
+    return iAllowedResults == rspV1.iGeneralResult ? KErrNone : KErrCorrupt;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::RefreshAllowed
+// Response to RefreshRequired notify. Tells if the refresh is allowed by
+// the Client.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyRefresh::RefreshAllowed
+        (
+        TDesC8* aDataPtr
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed ");
+    RSat::TRefreshRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aDataPtr );
+    RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) ();
+    if ( ( RSat::KSuccess == rspV1.iGeneralResult )
+        || ( RSat::KRefreshAdditionEFRead == rspV1.iGeneralResult ) )
+        {
+        // Refresh allowed, send refresh request to UICC
+        iSatMessHandler->UiccCatReqRefresh(
+            iSatMessaging->GetTransactionId(),
+            Map3GppRefreshToUiccValues( iCommandDetails[KCommandQualifier] ),
+            iFileList,
+            iAid );
+        }
+    else
+        {
+        // Refresh not allowed by the client
+        TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed, refresh was not \
+            allowed by the client");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed, refresh was not allowed by the client" );
+        TUint8 additionalInfo( 0x00 );
+        if ( RSat::KNoAdditionalInfo != rspV1.iInfoType )
+            {
+            additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+            }
+        // Send terminal response
+        iSatMessHandler->RefreshTerminalResp( iTransId,
+                                              iCommandDetails,
+                                              TUint8( rspV1.iGeneralResult ),
+                                              additionalInfo );
+        }
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::Map3GppRefreshToUiccValues
+// Maps 3GPP refresh values to match with UICC values.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint8 CSatNotifyRefresh::Map3GppRefreshToUiccValues
+        (
+        const TUint8 a3GppRefresh // 3GPP refresh level
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MAP3GPPREFRESHTOUICCVALUES, "CSatNotifyRefresh::Map3GppRefreshToUiccValues" );
+    TFLOGSTRING("TSY: CSatNotifyRefresh::Map3GppRefreshToUiccValues ");
+
+    TUint8 serviceType( a3GppRefresh );
+    switch ( serviceType )
+        {
+        case KSimInitFullFileChangeNotification:
+            {
+            serviceType = UICC_REFRESH_NAA_INIT_FULL_FILE_CHANGE;
+            break;
+            }
+        case KFileChangeNotification:
+            {
+            serviceType = UICC_REFRESH_NAA_FILE_CHANGE;
+            break;
+            }
+        case KSimInitFileChangeNotification:
+            {
+            serviceType = UICC_REFRESH_NAA_INIT_FILE_CHANGE;
+            break;
+            }
+        case KSimInit:
+            {
+            serviceType = UICC_REFRESH_NAA_INIT;
+            break;
+            }
+        case KSimReset:
+            {
+            serviceType = UICC_REFRESH_UICC_RESET;
+            break;
+            }
+        case KUSIMApplicationReset:
+            {
+            serviceType = UICC_REFRESH_NAA_APPLICATION_RESET;
+            break;
+            }
+        case K3GSessionReset:
+            {
+            serviceType = UICC_REFRESH_NAA_SESSION_RESET;
+            break;
+            }
+        default:
+            {
+            break;
+            }
+        }
+    return serviceType;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::CompleteRequest
+// Overloads original protected CompleteRequest method from Base class.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyRefresh::CompleteRequest
+        (
+        const TInt aError
+        )
+    {
+    OstTraceExt2( TRACE_NORMAL, CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Handle: %d, Error: %d", (TInt)iReqHandle, aError );
+    TFLOGSTRING3("CSatNotifyRefresh::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d",
+               iReqHandle,
+               aError);
+    TTsyReqHandle tempReqHandle = iReqHandle;
+    iReqHandle = NULL;
+    iSatMessaging->ReqCompleted( tempReqHandle, aError );
+    TFLOGSTRING("CSatNotifyRefresh::CompleteRequest. Request is now completed");
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Request is now completed" );
+
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyRefresh::CachedFiles
+// Returns list of files that are cached in SIM ATK TSY
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint16 CSatNotifyRefresh::CachedFiles() const
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CACHEDFILES, "CSatNotifyRefresh::CachedFiles" );
+    return iInternalCache;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySimSessionEnd::CSatNotifySimSessionEnd
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySimSessionEnd::CSatNotifySimSessionEnd
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::CSatNotifySimSessionEnd" );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd" );
+    // None
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySimSessionEnd::MessageReceived
+// Handles a SimSessionEnd proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySimSessionEnd::MessageReceived
+        (
+        const TIsiReceiveC& /*aIsiMessage*/ // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_MESSAGERECEIVED, "CSatNotifySimSessionEnd::MessageReceived" );
+    TFLOGSTRING("CSatNotifySimSessionEnd::MessageReceived");
+    if ( iReqHandle ) // If request on
+        {
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySimSessionEnd::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SimSessionEnd PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySimSessionEnd::Notify
+        (
+        const TTsyReqHandle aReqHandle,     // Request handle
+        TDes8*           /* aDataPtr */     // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_NOTIFY, "CSatNotifySimSessionEnd::Notify" );
+    TFLOGSTRING("CSatNotifySimSessionEnd::Notify");
+    iReqHandle = aReqHandle;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSetUpIdleModeTextV1Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpIdleModeText::MessageReceived
+// Handles a SetUpIdleModeText proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpIdleModeText::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived" );
+    TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+     //get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->SetUpIdleModeTextTerminalResp(
+             iTransId,
+             iCommandDetails,
+             RSat::KMeUnableToProcessCmd,
+             KNoCause );
+        }
+    else
+        {
+        // Fill the set up idle mode text structure
+        RSat::TSetUpIdleModeTextV1& setUpIdleModeTextV1
+            = ( *iSetUpIdleModeTextV1Pckg )();
+        setUpIdleModeTextV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        //Initialize Type to notSet, coding scheme to unicode and text to zero
+        setUpIdleModeTextV1.iType = RSat::ESetUpIdleModeTextTypeNotSet;
+        setUpIdleModeTextV1.iCodingScheme = RSat::E16bitUCS2;
+        setUpIdleModeTextV1.iText.Zero();
+        CTlv textString;
+        returnValue = berTlv.TlvByTagValue( &textString,
+            KTlvTextStringTag );
+        // If the returnValue is KErrNone
+        if ( KErrNone == returnValue )
+            {
+            if ( textString.GetLength() )
+                {
+                // Convert and set text
+                TSatUtility::SetText( textString, setUpIdleModeTextV1.iText );
+                //set type
+                setUpIdleModeTextV1.iType = RSat::EUpdateIdleModeText;
+                }
+            else
+                {
+                //set type
+                setUpIdleModeTextV1.iType = RSat::ERemoveExistingIdleModeText;
+                }
+            }
+        else
+            {
+            TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived \
+            No TLV text string found");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived No TLV text string found" );
+            iSatMessHandler->SetUpIdleModeTextTerminalResp(
+                iTransId,
+                iCommandDetails,
+                RSat::KCmdDataNotUnderstood,
+                KNoCause );
+            ret = KErrCorrupt;
+            }
+        // Iconid (optional)
+        TSatUtility::FillIconStructure( berTlv,
+            setUpIdleModeTextV1.iIconId );
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpIdleModeText::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SetUpIdleModeText PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpIdleModeText::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_NOTIFY, "CSatNotifySetUpIdleModeText::Notify" );
+    TFLOGSTRING("CSatNotifySetUpIdleModeText::Notify");
+    iReqHandle = aReqHandle;
+    iSetUpIdleModeTextV1Pckg =
+     static_cast< RSat::TSetUpIdleModeTextV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSetUpIdleModeText );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpIdleModeText::TerminalResponse
+// Handles a SetUpIdleModeText terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySetUpIdleModeText::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_TERMINALRESPONSE, "CSatNotifySetUpIdleModeText::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySetUpIdleModeText::TerminalResponse");
+    TInt   ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSetUpIdleModeTextRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSetUpIdleModeTextRspV1Pckg* >( aRsp );
+    RSat::TSetUpIdleModeTextRspV1& rspV1 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Equipment) error, additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( rspV1.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    // Creating the info message
+    iSatMessHandler->SetUpIdleModeTextTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV1.iGeneralResult ), additionalInfo );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::CSatNotifyCallControlRequest
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyCallControlRequest::CSatNotifyCallControlRequest
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iCallControlPckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::CSatNotifyCallControlRequest" );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::MessageReceived
+// Handles a CallControlRequest proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCallControlRequest::MessageReceived
+        (
+        const TIsiReceiveC& /*aIsiMessage*/ // ISI  message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyCallControlRequest::MessageReceived" );
+    // In S60 phones, the call control request is received via an ISI
+    // message coming from the ATK Guardian / Call server. That's why the body
+    // of this method is empty, see the class CSatCC. The Etel Sat API is used
+    // to pass to S60 Sat Server the alpha identifier provided by the SIM,
+    // if any. The SIM can provide such an alpha id to tell the user that the
+    // number to be called has been modified by the SIM.
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::CompleteNotification
+// Handles the Call Control notification received from ATK Guardian Server.
+// Completes an Etel Sat API CallControlRequest pending request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCallControlRequest::CompleteNotification
+        (
+        TDesC& aAlphaId,
+        RSat::TControlResult aResult
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" );
+    TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification");
+    //check that someone has requested this notifications
+    if ( iReqHandle )
+        {
+        // Temporary storage for Alpha Id
+        RSat::TAlphaId alphaId;
+        // Alpha ID validity
+        RSat::TAlphaIdValidity validity( RSat::EValidAlpaId );
+        alphaId.iStatus = RSat::EAlphaIdProvided;
+        alphaId.iAlphaId.Append( aAlphaId );
+        // Fill the call control structure
+        RSat::TCallControlV5& callControl = ( *iCallControlPckg )();
+
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+        if ( RSat::KSatV6 == callControl.ExtensionId() )
+            {
+            callControl = ( RSat::TCallControlV6& )callControl;
+            callControl = ( *iCallControlPckg )();
+            }
+#endif
+
+        // Set default control result
+        callControl.SetCcGeneralResult( aResult );
+        callControl.SetAlphaId( validity, alphaId );
+        // Complete notification
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::CompleteNotification
+// Handles the Call Control GPRS notification received from ATK Guardian Server.
+// Completes an Etel Sat API CallControlRequest pending request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCallControlRequest::CompleteNotification
+        (
+        const TDesC& aAlphaId,
+        const RSat::TControlResult aResult
+        )
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" );
+    TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification");
+    // Check that someone has requested this notifications
+    if ( iReqHandle )
+        {
+        // Create the call control structure
+        RSat::TCallControlV5& callControl = ( *iCallControlPckg )();
+
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+        // Check which version in use
+        if ( RSat::KSatV6 == callControl.ExtensionId() )
+            {
+            callControl = ( RSat::TCallControlV6& )callControl;
+            callControl = ( *iCallControlPckg )();
+            }
+#endif
+
+        // Check if the Alpha ID is present
+        if ( aAlphaId.Length() )
+            {
+            // Temporary storage for Alpha Id
+            RSat::TAlphaId alphaId;
+            // Alpha ID validity
+            RSat::TAlphaIdValidity validity( RSat::EValidAlpaId );
+            alphaId.iStatus = RSat::EAlphaIdProvided;
+            alphaId.iAlphaId.Append( aAlphaId );
+            // Set Alpha ID data
+            callControl.SetAlphaId( validity, alphaId );
+            }
+
+        // The PDP Parameters need to be set even though they are not present.
+        // Otherwise the Call Control Type will not be set to ECcPDPParameters
+        // Temporary storage for PDP Context Parameters
+        TPdpParameters pdpParameters;
+        // Set empty PDP Parameters data
+        callControl.SetPdpParameters( pdpParameters );
+
+        // Set call control result
+        callControl.SetCcGeneralResult( aResult );
+        // In Call control on GPRS, action originator is always modem
+        callControl.SetActionOriginator( RSat::EMeSideOriginator );
+        // Complete notification
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::CompleteNotificationL
+// Completes an Etel Sat API CallControlRequest pending request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCallControlRequest::CompleteNotificationL
+        (
+        const TUint8 aCcResult,
+        TPtrC8 aEnvelopeResponse
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL" );
+    TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL");
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+    // Check that someone has requested this notifications
+    if ( iReqHandle )
+        {
+        // When this method is used V6 structure is always used. Therefore
+        // casting is needed. Otherwise compiler gives errors.
+        // Create the call control structure.
+        RSat::TCallControlV6& callControl =
+            ( *(RSat::TCallControlV6Pckg*)iCallControlPckg )();
+
+        switch ( aCcResult )
+            {
+            case KAllowed:
+                {
+                callControl.SetCcGeneralResult( RSat::EAllowedNoModification );
+                // Cellmo continues with original operation
+                callControl.SetActionOriginator( RSat::EMeSideOriginator );
+                break;
+                }
+            case KRejected:
+                {
+                callControl.SetCcGeneralResult( RSat::ENotAllowed );
+                // original operation is rejected
+                callControl.SetActionOriginator( RSat::EMeSideOriginator );
+                break;
+                }
+            case KModified:
+                {
+                callControl.SetCcGeneralResult(
+                    RSat::EAllowedWithModifications );
+                // With cellmo value ATK_MODIFIED, same action is modified to
+                // similar action and cellmo takes care of this
+                callControl.SetActionOriginator( RSat::EMeSideOriginator );
+                break;
+                }
+            case KChanged:
+                {
+                callControl.SetCcGeneralResult(
+                    RSat::EAllowedWithModifications );
+                // With cellmo value ATK_CHANGED, same action is modified to
+                // another action and client is supposed to care of next action
+                callControl.SetActionOriginator( RSat::EClientOriginator );
+                break;
+                }
+            default:
+                {
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL\
+                    Not a valid call control result");
+                OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Not a valid call control result" );
+                break;
+                }
+            }
+        TInt ret( KErrNotFound );
+        // Initialize ton and npi
+        RSat::TTypeOfNumber ton( RSat::EUnknownNumber );
+        RSat::TNumberingPlan npi( RSat::EUnknownNumberingPlan );
+        // incoming ber-tlv
+        CBerTlv response;
+        response.SetData( aEnvelopeResponse );
+
+        CTlv ssString;
+        CTlv ussdTlv;
+
+        if ( KErrNone == response.TlvByTagValue( &ssString, KTlvSsStringTag ) )
+            {
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                Modified to SS");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to SS" );
+            // This SS related
+            RSat::TSsString tempSs;
+            // Call utility function that maps received TON and NPI
+            // to RSat values
+            TSatUtility::GetTonAndNpi(
+                ssString.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi );
+            // Set TON and NPI
+            tempSs.iTypeOfNumber = ton;
+            tempSs.iNumberPlan = npi;
+
+            TBuf8<RSat::KStringMaxSize> tempString;
+            // Check length of SS string.
+            // BCD format = two digits "packed" in one characher
+            if ( ssString.GetLength() * 2 <= RSat::KStringMaxSize )
+                {
+                // Semi-octet presentation used
+                // Converting back to ASCII format
+                TSatUtility::BCDToAscii(
+                    ssString.GetData( ETLV_SsOrUssdString ),
+                    tempString );
+
+                tempSs.iSsString.Append( tempString );
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    SetSendSsDetails");
+                OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendSsDetails" );
+                // Set SS string to struct
+                callControl.SetSendSsDetails( tempSs );
+                // Notify NokiaTSY that next SS request is SAT originated
+                TFLOGSTRING("TSY: Inform NokiaTSY SS request being Call Control originated");
+                OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "Inform NokiaTSY SS request being Call Control originated" );
+                iSatMessaging->GetMessageRouter()->ExtFuncL(
+                    ESatNotifyCallControlRequest,
+                    NULL );
+                }
+            else
+                {
+                // SS string is too long
+                ret = KErrCorrupt;
+                }
+            }
+        else if ( KErrNone ==
+                    response.TlvByTagValue( &ussdTlv, KTlvUssdStringTag ) )
+            {
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                Modified to USSD");
+            OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to USSD" );
+            // This is USSD related
+            RSat::TUssdString tempUssd;
+            // Get the data coding scheme from the ISI msg
+            // and set the corresponding ETel Sat data field.
+            tempUssd.iDcs = ussdTlv.GetShortInfo( ETLV_DataCodingScheme );
+
+            // Check length of USSD string
+            if ( ussdTlv.GetLength() <= RSat::KStringMaxSize )
+                {
+                // Client wants USSD data as received from SIM
+                tempUssd.iUssdString.Copy(
+                    ussdTlv.GetData( ETLV_UssdString ) );
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    SetSendUssdDetails");
+                OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendUssdDetails" );
+                callControl.SetSendUssdDetails( tempUssd );
+                }
+            else
+                {
+                // USSD string is too long
+                ret = KErrCorrupt;
+                }
+            }
+        else
+            {
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                Modified to Call");
+            OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to Call" );
+            // This must be call related response
+            CTlv addressTlv;
+
+            RSat::TCallSetUpParams tempCallParams;
+
+            ret = response.TlvByTagValue( &addressTlv, KTlvAddressTag );
+            if ( KErrNone == ret && addressTlv.GetLength() )
+                {
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    Address found");
+                OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Address found" );
+
+                // Call utility function that maps received TON and NPI to
+                // RSat values
+                TSatUtility::GetTonAndNpi(
+                    addressTlv.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi );
+                // Set TON and NPI
+                tempCallParams.iAddress.iTypeOfNumber = ton;
+                tempCallParams.iAddress.iNumberPlan = npi;
+                // Address
+                tempCallParams.iAddress.iTelNumber.Zero();
+                // length is number of BCD characters,
+                // multiply by two to get real length and - 2 for ton&npi
+                TInt dialNumberLength(
+                    ( ( addressTlv.GetLength() * 2 ) - 2 ) );
+
+                if ( dialNumberLength )
+                    {
+                    // Semi-octet presentation used
+                    TBuf8<RSat::KMaxMobileTelNumberSize> tempNumber;
+                    // Convert BCD string to ascii
+                    TSatUtility::BCDToAscii(
+                        addressTlv.GetData( ETLV_DiallingNumberString ),
+                        tempNumber );
+
+                    // add '+' character to the preceding of international
+                    // number
+                    if ( ( tempCallParams.iAddress.iTypeOfNumber
+                        == RSat::EInternationalNumber )
+                        && ( tempNumber[ 0 ] != KPlusMarkCharacterCode )
+                        && RSat::KMaxMobileTelNumberSize > dialNumberLength )
+                        {
+                        _LIT8( KPlusMark, "+");
+                        tempNumber.Insert( 0, KPlusMark );
+                        }
+
+                    // Set actual number
+                    tempCallParams.iAddress.iTelNumber.Copy( tempNumber );
+                    }
+                }
+            // Check if Capability configuration parameters 1 are found
+            CTlv bcc1;
+            ret = response.TlvByTagValue(
+                &bcc1,
+                KTlvCapabilityConfigurationParametersTag );
+
+            if ( KErrNone == ret )
+                {
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    bcc1 found");
+                OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc1 found" );
+                // BC length is the first byte in BC data
+                tempCallParams.iCcp1.Copy(
+                    bcc1.GetData( ETLV_CapabilityConfigurationParameters ) );
+                }
+
+            // Subaddress (optional)
+            CTlv subAddress;
+            ret = response.TlvByTagValue( &subAddress, KTlvSubaddressTag );
+            if ( KErrNone == ret )
+                {
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    subaddress found");
+                OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL subaddress found" );
+                tempCallParams.iSubAddress.Copy(
+                    subAddress.GetData( ETLV_SubAddress ) );
+                }
+            // Capability configuration parameters 2
+            // --> BC repeat indicator is mandatory, only if BCC2 present
+            CTlv bcc2;
+            ret = response.TlvByTagValue(
+                &bcc2,
+                KTlvCapabilityConfigurationParametersTag,
+                1 );
+
+            if ( KErrNone == ret )
+                {
+                TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                    bcc2 found");
+                OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc2 found" );
+                CTlv bcRepeat;
+                ret = response.TlvByTagValue(
+                    &bcRepeat,
+                    KTlvBcRepeatIndicatorTag );
+
+                if ( KErrNone == ret )
+                    {
+                    // If bcc2 present, BC repeat indicator is mandatory
+                    if ( ATK_CIRCULAR_REPEAT_INDICATOR ==
+                        bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) )
+                        {
+                        callControl.SetBCRepeatIndicator(
+                            RSat::EBCAlternateMode );
+                        }
+                    else if ( ATK_SEQUENTIAL_REPEAT_INDICATOR ==
+                        bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) )
+                        {
+                        callControl.SetBCRepeatIndicator(
+                            RSat::EBCFallbackMode );
+                        }
+                    else
+                        {
+                        // repeat indicator not valid
+                        ret = KErrCorrupt;
+                        }
+                    // If mandatory BC repeat indicator present
+                    if ( ret != KErrCorrupt )
+                        {
+                        tempCallParams.iCcp2.Copy(
+                            bcc2.GetData(
+                            ETLV_CapabilityConfigurationParameters ) );
+                        }
+                    }
+                }
+            // set call parameters
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                SetCallSetUpDetails");
+            OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetCallSetUpDetails" );
+            callControl.SetCallSetUpDetails( tempCallParams );
+            }
+        // Check if alpha id present
+        TPtrC8 sourceString; // Used with conversions
+        RSat::TAlphaId tempAlphaId;
+        RSat::TAlphaIdValidity tempValidity( RSat::EAlphaIdValidityNotSet );
+        CTlv alphaIdentifier;
+        // Get alpha id tlv from berTlv
+        ret = response.TlvByTagValue(
+            &alphaIdentifier,
+            KTlvAlphaIdentifierTag );
+        // if alpha id string exist
+        if ( KErrNone == ret )
+            {
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                Alpha id found");
+            OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha id found" );
+            if ( alphaIdentifier.GetLength() )
+                {
+                // 8-bit string to 16-bit string
+                sourceString.Set(
+                    alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+
+                // Convert and set the alpha id
+                TSatUtility::SetAlphaId(
+                    sourceString, tempAlphaId.iAlphaId );
+                // Set alpha id status
+                tempAlphaId.iStatus = RSat::EAlphaIdProvided;
+                tempValidity = RSat::EValidAlpaId;
+                }
+            else
+                {
+                tempAlphaId.iStatus = RSat::EAlphaIdNull;
+                tempValidity = RSat::ENullAlphaId;
+                }
+            }
+        // Alpha id not present
+        else
+            {
+            TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+                Alpha ID not present");
+            OstTrace0( TRACE_NORMAL, DUP14_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha ID not present" );
+            tempAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            tempValidity = RSat::ENoAlphaId;
+            }
+        // Set alpha id values
+        TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+            SetAlphaId");
+        OstTrace0( TRACE_NORMAL, DUP15_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetAlphaId" );
+        callControl.SetAlphaId( tempValidity, tempAlphaId );
+        TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
+            SetCallParamOrigin");
+        OstTrace0( TRACE_NORMAL, DUP18_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification SetCallParamOrigin" );
+
+        CompleteRequest( KErrNone );
+        }
+#endif
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCallControlRequest::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a CallControlRequest PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCallControlRequest::Notify
+        (
+        const TTsyReqHandle aReqHandle,
+        TDes8* aDataPtr
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_NOTIFY, "CSatNotifyCallControlRequest::Notify" );
+    TFLOGSTRING("CSatNotifyCallControlRequest::Notify");
+    iReqHandle = aReqHandle;
+
+    iCallControlPckg = static_cast<RSat::TCallControlV5Pckg*>( aDataPtr );
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iLaunchBrowserV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser
+        + RSat::KLaunchBrowserError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLaunchBrowser::MessageReceived
+// Handles a LaunchBrowser proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLaunchBrowser::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_MESSAGERECEIVED, "CSatNotifyLaunchBrowser::MessageReceived" );
+    TFLOGSTRING("CSatNotifyLaunchBrowser::MessageReceived");
+    //get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    // Get command qualifier
+    TUint8 cmdQualifier( commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        iSatMessHandler->LaunchBrowserTerminalResp(
+            iTransId, iCommandDetails,
+            RSat::KMeUnableToProcessCmd,
+            KNoCause );
+        }
+    else if ( CSatMessHandler::ENotBusy != iSatMessHandler->SsStatus() )
+        {
+        TUint8 additionalInfo( RSat::KMeBusyOnSs );
+        if( CSatMessHandler::EUssdBusy == iSatMessHandler->SsStatus() )
+            {
+            additionalInfo = RSat::KMeBusyOnUssd;
+            }
+        // Ss or Ussd transaction ongoing
+        iSatMessHandler->LaunchBrowserTerminalResp(
+            iTransId, iCommandDetails,
+            RSat::KMeUnableToProcessCmd,
+            additionalInfo );
+        }
+    else
+        {
+        TInt ret( KErrNone );
+        TInt returnValue( KErrNone );
+        // Launch browser structure
+        RSat::TLaunchBrowserV2& launchBrowserV2 = ( *iLaunchBrowserV2Pckg )();
+        launchBrowserV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ));
+        switch ( cmdQualifier )
+            {
+            case KLaunchBrowserIfNotYetLaunched:
+               {
+                launchBrowserV2.iBrowserSel =
+                    RSat::ELaunchBrowserIfNotAlreadyLaunched;
+                }
+                break;
+            case KUseExistingBrowser:
+                {
+                launchBrowserV2.iBrowserSel = RSat::EUseExistingBrowser;
+                break;
+                }
+            case KCloseAndLaunchNewBrowser:
+                {
+                launchBrowserV2.iBrowserSel =
+                    RSat::ECloseExistingLaunchNewBrowserSession;
+                break;
+                }
+            case KLaunchBrowserCmdQualifierNotUsed:
+            case KLaunchBrowserCmdQualifierReserved:
+                {
+                iSatMessHandler->LaunchBrowserTerminalResp(
+                    iTransId, iCommandDetails,
+                    RSat::KCmdTypeNotUnderstood, KNoCause );
+                ret = KErrCorrupt;
+                break;
+                }
+            default:
+                {
+                launchBrowserV2.iBrowserSel = RSat::EBrowserSelectionNotSet;
+                break;
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            CTlv browserId; // optional
+            returnValue = berTlv.TlvByTagValue( &browserId,
+                KTlvBrowserIdentityTag );
+            if ( KErrNotFound != returnValue )
+                {
+                // Browser id 0x00-0x04 allowed, other values are RFU
+                switch ( browserId.GetShortInfo( ETLV_BrowserIdentity ) )
+                    {
+                    case KDefaultBrowser:
+                        {
+                        launchBrowserV2.iBrowserId = RSat::EDefaultBrowser;
+                        break;
+                        }
+#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
+                    case KWMLBrowser:
+                        {
+                        launchBrowserV2.iBrowserId = RSat::EWMLBrowser;
+                        break;
+                        }
+                    case KHTMLBrowser:
+                        {
+                        launchBrowserV2.iBrowserId = RSat::EHTMLBrowser;
+                        break;
+                        }
+                    case KXHTMLBrowser:
+                        {
+                        launchBrowserV2.iBrowserId = RSat::EXHTMLBrowser;
+                        break;
+                        }
+                    case KCHTMLBrowser:
+                        {
+                        launchBrowserV2.iBrowserId = RSat::ECHTMLBrowser;
+                        break;
+                        }
+#endif
+                    default:
+                        {
+                        // Object present but does not identify a known
+                        // browser ID
+                        launchBrowserV2.iBrowserId =
+                            RSat::EBrowserIdNotSpecified;
+                        break;
+                        }
+                    }
+                }
+            else
+                {
+                launchBrowserV2.iBrowserId = RSat::EBrowserIdNotPresent;
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            CTlv url; // mandatory
+            returnValue = berTlv.TlvByTagValue( &url, KTlvUrlTag );
+            if ( KErrNotFound != returnValue )
+                {
+                if ( RSat::KUrlMaxSize < url.GetLength() )
+                    {
+                    iSatMessHandler->LaunchBrowserTerminalResp(
+                        iTransId, iCommandDetails,
+                        RSat::KMeUnableToProcessCmd, KNoCause );
+                    ret = KErrCorrupt;
+                    }
+                else
+                    {
+                    launchBrowserV2.iUrl.Copy( url.GetData( ETLV_Url ) );
+                    }
+                }
+            else
+                {
+                iSatMessHandler->LaunchBrowserTerminalResp(
+                    iTransId, iCommandDetails,
+                    RSat::KErrorRequiredValuesMissing, KNoCause );
+                ret = KErrCorrupt;
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            CTlv provisioningFileList; // optional
+            returnValue = berTlv.TlvByTagValueMulti( &provisioningFileList,
+                KTlvProvisioningReferenceFileTag );
+            TPtrC8 fileRefData = provisioningFileList.Data();
+            TUint8 numberOfFileRefData( 0 );
+            TInt ind( 0 );
+            TInt tlvLength( 0 );
+            TInt currentTlv( 0 );
+            if ( KErrNotFound != returnValue )
+                {
+                // search for number of file references
+                TInt i( 0 );
+                for ( i = 0; i < fileRefData.Length(); i += tlvLength )
+                    {
+                    //first determine if the length of the TLV is coded
+                    // with 1 or 2 bytes.
+                    if ( KTwoByteLengthCoding == fileRefData[ind+1] )
+                        {
+                        //length is coded with 2 bytes -> 1 extra byte required
+                        // to be
+                        //added to total length. Also TLV header bytes (2)
+                        // must be added
+                        //to total length
+                        tlvLength = fileRefData[ind+2] + KTlvHeaderLength + 1;
+                        }
+                    else
+                        {
+                        //TLV header bytes (2) must be added to total length
+                        tlvLength = fileRefData[ind+1]  + KTlvHeaderLength;
+                        }
+
+                    currentTlv = fileRefData[ind];
+                    if ( KTlvProvisioningReferenceFileTag == currentTlv )
+                        {
+                            numberOfFileRefData++;
+                        }
+
+                    ind += tlvLength;
+                    }
+                RSat::TProvisioningFileRef newFileRef;
+                // Set string length and pos
+                TUint8 stringLength( 0 );
+                TUint  pos( 2 );
+                // add FileReferences to the structure launchBrowserV2
+                for ( i = 0; ( i < numberOfFileRefData ) && ( KErrNone == ret );
+                    i++ )
+                    {
+                    // Fill the newfileref
+                    stringLength = TUint8( fileRefData[pos - 1] );
+                    // Test whether the text contains more than "MF"
+                    if ( ( RSat::KFileRefMaxSize < stringLength )
+                        || ( 4 > stringLength ) )
+                        {
+                        iSatMessHandler->LaunchBrowserTerminalResp(
+                            iTransId, iCommandDetails,
+                            RSat::KLaunchBrowserError,
+                            RSat::KMeUnableToReadProvisioningData );
+                        ret = KErrCorrupt;
+                        break;
+                        }
+                    newFileRef.Zero();
+                    TUint8 x( 0 );
+                    for ( x = 0; x < stringLength; x++ )
+                        {
+                        newFileRef.Append( fileRefData[pos+x] );
+                        }
+                     // Adding the new fileref
+                    if ( KErrNoMemory ==
+                         launchBrowserV2.AddFileRef( newFileRef ) )
+                        {
+                        // Too many or long menuitems
+                        iSatMessHandler->LaunchBrowserTerminalResp(
+                            iTransId, iCommandDetails,
+                            RSat::KLaunchBrowserError,
+                            RSat::KMeUnableToReadProvisioningData );
+                        ret = KErrCorrupt;
+                        }
+                    // Calculating the new position
+                    pos = TUint( pos + fileRefData[pos - 1] + 2 );
+                    }
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            // Bearers (optional)
+            CTlv bearerList;
+            returnValue = berTlv.TlvByTagValue( &bearerList,
+                KTlvBearerTag );
+            if ( KErrNotFound != returnValue )
+                {
+                if ( RSat::KBearerListMaxSize >= bearerList.GetLength() )
+                    {
+                    TBuf8<RSat::KBearerListMaxSize> brList =
+                        bearerList.GetData( ETLV_ListOfBearers );
+                    // SMS or USSD are not available bearers.
+                    TInt i( 0 );
+                    for ( i = 0; i < brList.Length() ; i++)
+                        {
+                        if ( KCsdBearer == brList[i]
+                            || KGprsBearer == brList[i] )
+                            {
+                            launchBrowserV2.iBearerList.Append( brList[i] );
+                            }
+                        }
+                    if ( 0x00 == launchBrowserV2.iBearerList.Length() )
+                        {
+                        iSatMessHandler->LaunchBrowserTerminalResp(
+                            iTransId, iCommandDetails,
+                            RSat::KLaunchBrowserError,
+                            RSat::KBearerUnvailable );
+                        ret = KErrCorrupt;
+                        }
+                    }
+                else
+                    {
+                    iSatMessHandler->LaunchBrowserTerminalResp(
+                        iTransId, iCommandDetails,
+                        RSat::KCmdDataNotUnderstood, KNoCause );
+                    ret = KErrCorrupt;
+                    }
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            // Text string (Gateway/Proxy)
+            CTlv textString;
+            returnValue = berTlv.TlvByTagValue( &textString,
+                                                KTlvTextStringTag );
+            if ( KErrNone == returnValue )
+                {
+                TSatUtility::SetText( textString, launchBrowserV2.iText );
+                }
+            }
+        if ( KErrNone == ret )
+            {
+            // Alpha ID string (optional) for user confirmation phase
+            CTlv alphaIdentifier;
+            returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+                KTlvAlphaIdentifierTag );
+            launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            if ( KErrNotFound != returnValue )
+                {
+                TUint8 alphaIdLength( alphaIdentifier.GetLength() );
+                if ( alphaIdLength )
+                    {
+                    TPtrC8 sourceString;
+
+                    // get the alpha id
+                    sourceString.Set(
+                        alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+
+                    // convert and set the alpha id
+                    TSatUtility::SetAlphaId( sourceString ,
+                        launchBrowserV2.iAlphaId.iAlphaId );
+
+                    launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+            // Iconid
+            TSatUtility::FillIconStructure( berTlv,
+                launchBrowserV2.iIconId );
+            CompleteRequest( ret );
+            }
+
+        } // end else
+
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLaunchBrowser::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a LaunchBrowser PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLaunchBrowser::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_NOTIFY, "CSatNotifyLaunchBrowser::Notify Handle :%u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyLaunchBrowser::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iLaunchBrowserV2Pckg = static_cast< RSat::TLaunchBrowserV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KLaunchBrowser );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLaunchBrowser::TerminalResponse
+// Handles a LaunchBrowser terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyLaunchBrowser::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_TERMINALRESPONSE, "CSatNotifyLaunchBrowser::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyLaunchBrowser::TerminalResponse");
+    TInt   ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TLaunchBrowserRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TLaunchBrowserRspV2Pckg* >( aRsp );
+    RSat::TLaunchBrowserRspV2& rspV2 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // Check that infotype is valid: from enum TBrowserError in etelsat.h
+    if ( ( RSat::KMeProblem != rspV2.iInfoType )
+        && ( RSat::KNoAdditionalInfo != rspV2.iInfoType )
+        && ( RSat::KBearerUnvailable != rspV2.iInfoType )
+        && ( RSat::KBrowserUnavailable != rspV2.iInfoType )
+        && ( RSat::KMeUnableToReadProvisioningData != rspV2.iInfoType )
+        && ( RSat::KNoSpecificBrowserError != rspV2.iInfoType )
+        )
+        {
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Equipment) error, additional info is needed
+    if ( ( RSat::KMeProblem == rspV2.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( rspV2.iAdditionalInfo.Length() != 0 )
+            {
+            additionalInfo = TUint8( rspV2.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->LaunchBrowserTerminalResp(
+        iTransId,                                   // Transaction id
+        iCommandDetails,                            // Command number
+        TUint8( rspV2.iGeneralResult ),             // Result
+        additionalInfo );                           // Additional info
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpEventList::CSatNotifySetUpEventList
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpEventList::CSatNotifySetUpEventList
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSetUpEventListV1Pckg( NULL ),
+        iCmdQualifier( KZero ),
+        iEvents( KZero )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::CSatNotifySetUpEventList" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpEventList::~CSatNotifySetUpEventList
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySetUpEventList::~CSatNotifySetUpEventList()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::~CSatNotifySetUpEventList" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpEventList::MessageReceived
+// Handles a SetUpEventList proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpEventList::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived" );
+    TFLOGSTRING("CSatNotifySetUpEventList::MessageReceived");
+    TInt ret( KErrNone );
+    TUint8 generalResult( RSat::KSuccess );
+    //get ber tlv
+    CBerTlv berTlv;
+    ret = berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        generalResult = RSat::KMeUnableToProcessCmd;
+        }
+    else
+        {
+        // Let's fill the setup event list structure
+        RSat::TSetUpEventListV1& setUpEventListV1 = ( *iSetUpEventListV1Pckg )();
+        setUpEventListV1.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        CTlv eventListTlv;
+        ret = berTlv.TlvByTagValue( &eventListTlv, KTlvEventListTag );
+        //Initialize Type to Not set
+        setUpEventListV1.iType = RSat::ESetUpEventListTypeNotSet;
+        // If the returnValue is KErrNone
+        if ( KErrNone == ret )
+            {
+            iEvents = 0;
+            TPtrC8 setUpEventList = eventListTlv.GetData( ETLV_EventList );
+            TUint16 eventListLength = eventListTlv.GetLength();
+            if ( !eventListLength )
+                {
+                 setUpEventListV1.iType = RSat::ERemoveExistingEventList;
+                 // remove events from TSY:s list
+                 iSatMessaging->SetUpEventList( 0 ); // no events = 0
+                }
+            else
+                {
+                setUpEventListV1.iType = RSat::EUpdateEventList;
+                TInt8 i( 0 );
+                TBuf8<14> eventList;
+                eventList.FillZ( 14 );
+                for ( i = 0; i < eventListLength; i++ )
+                    {
+                    if(  KLocalConnection < setUpEventList[i] )
+                        {
+                        //Invalid event code
+                        generalResult = RSat::KCmdBeyondMeCapabilities;
+                        }
+                    else if( !eventList[setUpEventList[i]] )
+                        {
+                        //Each event type shall not appear more than ones
+                        eventList[ setUpEventList[i] ] = 0x01;
+                        switch( setUpEventList[i] )
+                            {
+                            case KMTCall:
+                                iEvents += RSat::KMTCall;
+                                break;
+                            case KCallConnected:
+                                iEvents += RSat::KCallConnected;
+                                break;
+                            case KCallDisconnected:
+                                iEvents += RSat::KCallDisconnected;
+                                break;
+                            case KLocationStatus:
+                                iEvents += RSat::KLocationStatus;
+                                break;
+                            case KUserActivity:
+                                setUpEventListV1.iEvents
+                                    += RSat::KUserActivity;
+                                iEvents += RSat::KUserActivity;
+                                break;
+                            case KIdleScreenAvailable:
+                                setUpEventListV1.iEvents
+                                    += RSat::KIdleScreenAvailable;
+                                iEvents += RSat::KIdleScreenAvailable;
+                                break;
+                            case KCardReaderStatus:
+                                setUpEventListV1.iEvents
+                                    += RSat::KCardReaderStatus;
+                                iEvents += RSat::KCardReaderStatus;
+                                break;
+                            case KLanguageSelection:
+                                setUpEventListV1.iEvents
+                                    += RSat::KLanguageSelection;
+                                iEvents += RSat::KLanguageSelection;
+                                break;
+                            case KBrowserTermination:
+                                setUpEventListV1.iEvents
+                                    += RSat::KBrowserTermination;
+                                iEvents += RSat::KBrowserTermination;
+                                break;
+                            case KDataAvailable:
+                                setUpEventListV1.iEvents
+                                    += RSat::KDataAvailable;
+                                iEvents += RSat::KDataAvailable;
+                                break;
+                            case KChannelStatus:
+                                setUpEventListV1.iEvents
+                                    += RSat::KChannelStatus;
+                                iEvents += RSat::KChannelStatus;
+                                break;
+                            case KAccessTechnologyChange:
+                                iEvents += RSat::KAccessTechnologyChange;
+                                break;
+                            case KDisplayParamsChanges:
+                                setUpEventListV1.iEvents
+                                    += RSat::KDisplayParamsChanges;
+                                iEvents += RSat::KDisplayParamsChanges;
+                                break;
+                            case KLocalConnection:
+                                setUpEventListV1.iEvents
+                                    += RSat::KLocalConnection;
+                                iEvents += RSat::KLocalConnection;
+                                break;
+                            default:
+                                break;
+                            }
+                        }
+                    else
+                        {
+                        TFLOGSTRING("TSY: \
+                        CSatNotifySetUpEventList::MessageReceived, \
+                        Event not recognized or not supported.");
+                        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived, Event not recognized or not supported." );
+                        }
+                    }
+                }
+            }
+        else
+            {
+            //Event list is missing
+            generalResult = RSat::KErrorRequiredValuesMissing;
+            }
+        }
+    if( RSat::KSuccess != generalResult )
+        {
+        iSatMessHandler->SetUpEventListTerminalResp(
+                                iTransId,
+                                iCommandDetails,
+                                generalResult,
+                                KNoCause );  // KNoCause: 0
+        }
+    else
+        {
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpEventList::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SetUpEventList PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySetUpEventList::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_NOTIFY, "CSatNotifySetUpEventList::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySetUpEventList::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iSetUpEventListV1Pckg = static_cast< RSat::TSetUpEventListV1Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSetUpEventList );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySetUpEventList::TerminalResponse
+// Handles a SetUpEventList terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySetUpEventList::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_TERMINALRESPONSE, "CSatNotifySetUpEventList::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySetUpEventList::TerminalResponse");
+    TInt   ret( KErrNone );
+    TUint8 additionalInfo( 0 );
+    RSat::TSetUpEventListRspV1Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSetUpEventListRspV1Pckg* >( aRsp );
+    RSat::TSetUpEventListRspV1& rspV1 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV1.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // If there is Me (Mobile Entity) error, additional info is needed
+    if ( ( RSat::KMeProblem == rspV1.iInfoType ) )
+        {
+        // Check the length of additional info
+        if ( NULL != rspV1.iAdditionalInfo.Length() )
+            {
+            additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] );
+            }
+        else
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        }
+    if( RSat::KSuccess == rspV1.iGeneralResult )
+        {
+        // set events to TSY:s list
+        iSatMessaging->SetUpEventList( iEvents );
+        }
+    iSatMessHandler->SetUpEventListTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV1.iGeneralResult ),
+        additionalInfo );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollingOff::CSatNotifyPollingOff
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPollingOff::CSatNotifyPollingOff
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::CSatNotifyPollingOff" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollingOff::~CSatNotifyPollingOff
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyPollingOff::~CSatNotifyPollingOff()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::~CSatNotifyPollingOff" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollingOff::MessageReceived
+// Handles a PollingOff proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPollingOff::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_MESSAGERECEIVED, "CSatNotifyPollingOff::MessageReceived" );
+    TFLOGSTRING("CSatNotifyPollingOff::MessageReceived");
+    //get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !( iSatMessHandler->PollingOff() ) )
+        {
+        iSatMessHandler->SetPollingOff( ETrue );
+        iSatMessHandler->SetPollingInterval(
+            iTransId,
+            KDefaultPollInterval );
+        // Terminal response is sent when the response
+        //from SIM server is received
+        }
+    else
+        {
+         // PollingOff is already off
+        iSatMessHandler->PollingOffTerminalResp(
+            iTransId,
+            iCommandDetails,
+            RSat::KSuccess,
+            RSat::KNoAdditionalInfo );
+            }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyPollingOff::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a PollingOff PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyPollingOff::Notify
+        (
+        const TTsyReqHandle /*aReqHandle*/, // Request handle
+        TDes8*              /*aDataPtr*/    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_NOTIFY, "CSatNotifyPollingOff::Notify" );
+    // PollingOff is completely implemented by SimAtkTsy. Client
+    // insn't notified about the command.
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::CSatNotifyLocalInfo
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLocalInfo::CSatNotifyLocalInfo
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iLocalInfoV3Pckg( NULL ),
+        iLocalInfoIsOngoing( EFalse )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::CSatNotifyLocalInfo" );
+    TFLOGSTRING("CSatNotifyLocalInfo::CSatNotifyLocalInfo");
+    // Initialize response structure
+    iLocalInfoRspV3 = RSat::TLocalInfoRspV3();
+
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessLimitedService
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::~CSatNotifyLocalInfo
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLocalInfo::~CSatNotifyLocalInfo()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::~CSatNotifyLocalInfo" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::MessageReceived
+// Handles a LocalInfo proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLocalInfo::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived" );
+    TFLOGSTRING("CSatNotifyLocalInfo::MessageReceived");
+    // Clear additional info
+    iLocalInfoRspV3.iAdditionalInfo.Zero();
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details tlv
+    iCommandDetails.Copy( commandDetails.Data() );
+    // Trans id
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    switch ( iCommandDetails[KCommandQualifier] )
+        {
+        case RSat::KProvideLocalInfo:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: LOCAL INFO");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: LOCAL INFO" );
+            iLocalInfoIsOngoing = ETrue;
+
+            // Send a net cell info request to the net server.
+            // Use same transaction id what comes with proactive
+            // command and compare that when response is received
+            iSatMessHandler->NetCellInfoGetReq( iTransId );
+
+            break;
+            }
+        case RSat::KProvideLocalInfoImei:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: IMEI");
+            OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: IMEI" );
+            // Check if IMEI is received
+            if ( iSatMessHandler->ImeiAvailable() )
+                {
+                // IMEI is received from info server
+                iLocalInfoRspV3.iGeneralResult = RSat::KSuccess;
+                }
+            else
+                {
+                // No IMEI available at the moment
+                iLocalInfoRspV3.iGeneralResult =
+                    RSat::KMeUnableToProcessCmd;
+                iLocalInfoRspV3.iAdditionalInfo.Append(
+                    KNoSpecificCauseCanBeGiven );
+                }
+            break;
+            }
+        case RSat::KProvideLocalInformationNmr:
+            {
+            // Check if UTRAN Measurement Qualifier TLV is present
+            CTlv utranMeasurement;
+            if ( KErrNone == berTlv.TlvByTagValue( &utranMeasurement,
+                                        KTlvUtranMeasurementQualifierTag ) )
+                {
+                // ME has to be connected to GERAN if UTRAN NMR's are requested
+                if ( KNetworkModeUtran ==
+                    iSatMessHandler->CurrentAccessTechnology() )
+                    {
+                    TFLOGSTRING("CSatNotifyLocalInfo:: request: UTRAN NMR");
+                    OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived UTRAN NMR" );
+
+                    switch( utranMeasurement.GetShortInfo(
+                                ETLV_UtranMeasurementQualifier ) )
+                        {
+                        case KIntraFrequencyMeasurements:
+                            {
+                            iLocalInfoIsOngoing = ETrue;
+                            TFLOGSTRING("CSatNotifyLocalInfo::INTRA_FREQ_NMR");
+                            OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived INTRA_FREQ_NMR" );
+                            iSatMessHandler->NetNeighbourCellsReq(
+                                            iSatMessaging->GetTransactionId(),
+                                            NET_SIM_INTRA_FREQ_NMR );
+                            break;
+                            }
+                        case KInterFrequencyMeasurements:
+                            {
+                            iLocalInfoIsOngoing = ETrue;
+                            TFLOGSTRING("CSatNotifyLocalInfo::INTER_FREQ_NMR");
+                            OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_FREQ_NMR" );
+                            iSatMessHandler->NetNeighbourCellsReq(
+                                            iSatMessaging->GetTransactionId(),
+                                            NET_SIM_INTER_FREQ_NMR );
+                            break;
+                            }
+                        case KInterRatMeasurements:
+                            {
+                            iLocalInfoIsOngoing = ETrue;
+                            TFLOGSTRING("CSatNotifyLocalInfo::INTER_RAT_NMR");
+                            OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_RAT_NMR" );
+                            iSatMessHandler->NetNeighbourCellsReq(
+                                            iSatMessaging->GetTransactionId(),
+                                            NET_SIM_INTER_RAT_NMR );
+                            break;
+                            }
+                        default:
+                            {
+                            iLocalInfoRspV3.iGeneralResult =
+                            RSat::KCmdDataNotUnderstood;
+                            TerminalResponse();
+                            break;
+                            }
+                        }
+                    }
+                else
+                    {
+                    // ME connected to GSM, cannot serve the requested command
+                    iLocalInfoRspV3.iGeneralResult =
+                    RSat::KMeUnableToProcessCmd;
+                    iLocalInfoRspV3.iAdditionalInfo.Append( KNoService );
+                    TerminalResponse();
+                    }
+                }
+            else
+                {
+                TFLOGSTRING("CSatNotifyLocalInfo:: request: NMR");
+                OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: NMR" );
+                iLocalInfoIsOngoing = ETrue;
+                // Request NET_SIM_NMR
+                iSatMessHandler->NetNeighbourCellsReq(
+                    iSatMessaging->GetTransactionId(),
+                    NET_SIM_NMR );
+                }
+
+            break;
+            }
+        case RSat::KProvideLocalInfoDateTimeTimeZone:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: DATE/TIME/TIMEZONE");
+            OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: DATE/TIME/TIMEZONE" );
+            TTime time;
+            TLocale locale;
+            TDateTime dateTime;
+            // Get Universal time
+            time.UniversalTime();
+            // Get Universal time offset ( Time zone in seconds )
+            TTimeIntervalSeconds universalTimeOffset(
+                locale.UniversalTimeOffset() );
+            // Add locale's universal time offset to universal time
+            // to get the local time
+            time += universalTimeOffset;
+            // Converts a TTime object into a TDateTime object
+            dateTime = time.DateTime();
+            // Get and conver year
+            TUint8 temp2( TSatUtility::ConvertToSemiOctet(
+                dateTime.Year() ) );
+            // Append year to additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Convert month
+            // Offset from zero. So adding one.
+            temp2 = TSatUtility::ConvertToSemiOctet(
+                dateTime.Month() + 1 );
+            // Append month value to the additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Convert day to the semi-octec presentation
+            // The day.Offset from zero, so add one before displaying
+            // the day number.
+            temp2 = TSatUtility::ConvertToSemiOctet(
+                dateTime.Day() + 1 );
+            // Append the day value to the additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Conver current time to the semi-octec presentation.
+            // First hour
+            temp2 = TSatUtility::ConvertToSemiOctet(
+                dateTime.Hour() );
+            // Append the hour value to the additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Minute value
+            temp2 = TSatUtility::ConvertToSemiOctet(
+                dateTime.Minute() );
+            // Append the minute value to the additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Seconds
+            temp2 = TSatUtility::ConvertToSemiOctet(
+                dateTime.Second() );
+            // Append the seconds value to the additional info
+            iLocalInfoRspV3.iAdditionalInfo.Append( temp2 );
+            // Append time zone
+            // received from NET_TIME_IND isi-message
+            iLocalInfoRspV3.iAdditionalInfo.Append(
+                iSatMessHandler->TimeZone() );
+            // Set generall result as Success
+            iLocalInfoRspV3.iGeneralResult = RSat::KSuccess;
+            break;
+            }
+        case RSat::KProvideLocalInfoLanguage:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: Language");
+            OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Language" );
+            if( !iReqHandle )
+                {
+                TFLOGSTRING("CSatNotifyLocalInfo:: No reqHandle");
+                OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived No reqHandle" );
+
+                iLocalInfoRspV3.iGeneralResult = RSat::KMeUnableToProcessCmd;
+                iLocalInfoRspV3.iAdditionalInfo.Append( RSat::KNoSpecificMeProblem );
+                TerminalResponse();
+                }
+            else
+                {
+                TFLOGSTRING("CSatNotifyLocalInfo:: reqHandle");
+                OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived reqHandle" );
+                // Fill the send sm structure
+                RSat::TLocalInfoV3& localInfoV3 = ( *iLocalInfoV3Pckg )();
+                // Get command details tlv
+                CTlv deviceIdentities;
+                berTlv.TlvByTagValue( &deviceIdentities, KTlvDeviceIdentityTag );
+                localInfoV3.iDevideId = ( RSat::TDeviceId )
+                    deviceIdentities.GetShortInfo( ETLV_SourceDeviceIdentity );
+                localInfoV3.iInfoType =
+                   ( RSat::TLocaInfomationType) iCommandDetails[KCommandQualifier];
+                localInfoV3.SetPCmdNumber(
+                    commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+                CompleteRequest( KErrNone );
+                }
+            break;
+            }
+        case RSat::KProvideLocalInfoTimingAdv:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: TimingAdvance");
+            OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: TimingAdvance" );
+            iLocalInfoIsOngoing = ETrue;
+            //request GSS_CS_SERVICE_REQ
+            iSatMessHandler->GssCsServiceReq(
+                             iSatMessaging->GetTransactionId(),
+                             GSS_ATK_TIMING_ADVANCE_GET );
+            break;
+            }
+        case RSat::KProvideLocalInfoAccTech:
+            {
+            TFLOGSTRING("CSatNotifyLocalInfo:: request: Access Technology");
+            OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Access Technology" );
+            iLocalInfoIsOngoing = ETrue;
+            //request NET_RAT_REQ
+            iSatMessHandler->NetRatReq( iSatMessaging->GetTransactionId() );
+            break;
+            }
+        // Currently not supported:
+        case RSat::KProvideLocalInfoESN:
+            {
+            iLocalInfoRspV3.iGeneralResult =
+                RSat::KCmdBeyondMeCapabilities;
+            break;
+            }
+        default:
+            {
+            iLocalInfoRspV3.iGeneralResult = RSat::KCmdTypeNotUnderstood;
+            }
+        }
+    if ( RSat::KProvideLocalInformationNmr !=
+            iCommandDetails[KCommandQualifier]
+        && RSat::KProvideLocalInfo != iCommandDetails[KCommandQualifier]
+        && RSat::KProvideLocalInfoTimingAdv != iCommandDetails[KCommandQualifier]
+        && RSat::KProvideLocalInfoLanguage != iCommandDetails[KCommandQualifier]
+        && RSat::KProvideLocalInfoAccTech != iCommandDetails[KCommandQualifier] )
+        {
+        // Send terminal response to the sim
+        TerminalResponse();
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a LocalInfo PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLocalInfo::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYLOCALINFO_NOTIFY, "CSatNotifyLocalInfo::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyLocalInfo::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iLocalInfoV3Pckg = static_cast< RSat::TLocalInfoV3Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KProvideLocalInformation );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::TerminalResponse
+// Handles a LocalInfo terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyLocalInfo::TerminalResponse
+        (
+        TDes8* aRsp     // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_TERMINALRESPONSE, "CSatNotifyLocalInfo::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyLocalInfo::TerminalResponse");
+    TInt ret( KErrNone );
+    if ( aRsp )
+        {
+        RSat::TLocalInfoRspV3Pckg* aRspPckg =
+                reinterpret_cast< RSat::TLocalInfoRspV3Pckg* >( aRsp );
+        RSat::TLocalInfoRspV3& rspV1 = ( *aRspPckg ) ();
+        // Check that general result value is valid.
+        if ( iAllowedResults != rspV1.iGeneralResult )
+            {
+            // Invalid general result
+            ret = KErrCorrupt;
+            }
+        iLocalInfoRspV3.iGeneralResult = rspV1.iGeneralResult;
+        // If there is Me (Mobile Entity) error, additional info is needed
+        if ( RSat::KMeProblem == rspV1.iInfoType &&
+             NULL == rspV1.iAdditionalInfo.Length() )
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        iLocalInfoRspV3.iAdditionalInfo = rspV1.iAdditionalInfo;
+        }
+    iSatMessHandler->LocalInfoTerminalResp(
+        iTransId,                            // Transaction id
+        iCommandDetails,                     // Command details tlv
+        TUint8( iLocalInfoRspV3.iGeneralResult ),  // Result
+        iLocalInfoRspV3.iAdditionalInfo );   // Additional info
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLocalInfo::Status
+// Method to check and set local info status. This is used when
+// SIM request NMR or Local Info.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CSatNotifyLocalInfo::Status
+        (
+        TBool aClearStatus
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_STATUS, "CSatNotifyLocalInfo::Status" );
+    TFLOGSTRING("CSatNotifyLocalInfo::Status");
+    if ( aClearStatus )
+        {
+        iLocalInfoIsOngoing = EFalse;
+        }
+    return iLocalInfoIsOngoing;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyTimerMgmt::CSatNotifyTimerMgmt
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyTimerMgmt::CSatNotifyTimerMgmt
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iCmdQualifier( KZero )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::CSatNotifyTimerMgmt" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KContradictionWithTimerState
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyTimerMgmt::MessageReceived
+// Handles a TimerMgmt proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyTimerMgmt::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_MESSAGERECEIVED, "CSatNotifyTimerMgmt::MessageReceived" );
+    TFLOGSTRING("CSatNotifyTimerMgmt::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+    TUint8 generalResult ( RSat::KSuccess );
+    //get ber tlv
+    CBerTlv berTlv;
+    returnValue = berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    // Get command qualifier
+    TUint8 cmdQualifier(
+        commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+    // get timer id tlv
+    CTlv timerId;
+    returnValue = berTlv.TlvByTagValue( &timerId,
+                           KTlvTimerIdentifierTag );
+    // initalize
+    TUint8 timerIdentifier( 0 );
+    TUint8 time[3] = {0, 0, 0};
+    if ( KErrNone == returnValue )
+        {
+        timerIdentifier = timerId.GetShortInfo( ETLV_TimerIdentifier );
+        // The Timer Identifier can take 8 different values
+        if ( ( RSat::KTimer8 < timerIdentifier  )
+             || ( RSat::KTimer1 > timerIdentifier ) )
+            {
+            generalResult = RSat::KCmdDataNotUnderstood;
+            }
+        else
+            {
+            // if operation type is startTimer = 0x00
+            if ( !cmdQualifier )
+                {
+                 //get timer value tlv
+                CTlv timerValue;
+                returnValue = berTlv.TlvByTagValue( &timerValue,
+                                                KTlvTimerValueTag );
+                if ( KErrNotFound != returnValue)
+                    {
+                    TPtrC8 temp;
+                    TUint32 timeValue( 0 );
+                    // value of a timer, expressed using
+                    // the format hour, minute, second
+                    // Semi-octec presentation used (23.040)
+                    temp.Set( timerValue.GetData( ETLV_TimerValue ) );
+                    //convert to seconds
+                    timeValue = ConvertToSeconds( temp );
+                    // The possible duration of a timer is
+                    // between 1 second and 24 hours
+                    if ( KMinTimerValue < timeValue &&
+                         KMaxTimerValueInSeconds >= timeValue )
+                        {
+                        ret = iSatMessaging->GetSatTimer()->
+                                   StartTimer( timerIdentifier, timeValue );
+                        if ( KErrNone != ret )
+                            {
+                            generalResult = RSat::KMeUnableToProcessCmd;
+                            }
+                        }
+                    else
+                        {
+                        generalResult = RSat::KCmdDataNotUnderstood;
+                        }
+                    }
+                else
+                    {
+                    generalResult = RSat::KErrorRequiredValuesMissing;
+                    }
+                }
+            // if operation type is KDeactivateTimer or KGetTimerValue
+            else if ( KDeactivateTimer == cmdQualifier ||
+                      KGetTimerValue == cmdQualifier )
+                {
+                TInt retValue( KErrNone );
+                //get current value of the timer
+                ret = iSatMessaging->GetSatTimer()->
+                          GetCurrentValueOfTimerById( timerIdentifier );
+                if ( KDeactivateTimer == cmdQualifier && KErrNotFound != ret )
+                    {
+                    //deactivate timer
+                    retValue = iSatMessaging->GetSatTimer()->
+                                      DeleteTimerById( timerIdentifier );
+                    }
+                //if timer is found convert timer value to semi-octets
+                if ( KErrNotFound != ret && KErrNotFound != retValue )
+                    {
+                    generalResult = RSat::KSuccess;
+                    TInt num[3];
+                    num[0] = ret/3600;         //hours
+                    num[1] = ( ret%3600 )/60;  //minutes
+                    num[2] = ( ret%3600 )%60;  //seconds
+                    TInt i( 0 );
+                    for ( i = 0; i < 3; i++ )
+                        {
+                        //convert to semi-octet
+                        time[i] = TSatUtility::ConvertToSemiOctet( num[i] );
+                        }
+                    }
+                else
+                    {
+                    generalResult = RSat::KContradictionWithTimerState;
+                    }
+                }
+            else
+                {
+                generalResult = RSat::KCmdTypeNotUnderstood;
+                }
+            }
+        }
+    else
+        {
+        generalResult = RSat::KErrorRequiredValuesMissing;
+        }
+    iSatMessHandler->TimerMgmtTerminalResp( aIsiMessage.Get8bit(
+        ISI_HEADER_OFFSET_TRANSID ), iCommandDetails, generalResult,
+        time, timerIdentifier, KNoCause );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyTimerMgmt::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a TimerManagement PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyTimerMgmt::Notify
+        (
+        const TTsyReqHandle /*aReqHandle*/, // Request handle
+        TDes8*              /*aDataPtr*/    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_NOTIFY, "CSatNotifyTimerMgmt::Notify" );
+    // TimerManagement is completely implemented by SimAtkTsy. Client
+    // insn't notified about the command.
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyTimerMgmt::ConvertToSeconds
+// Converts to seconds semi-octet presented value of timer,
+// expressed using the format hour, minute, second
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TUint32 CSatNotifyTimerMgmt::ConvertToSeconds
+         (
+         TPtrC8 time
+         )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CONVERTTOSECONDS, "CSatNotifyTimerMgmt::ConvertToSeconds" );
+    TFLOGSTRING("CSatNotifyTimerMgmt::ConvertToSeconds");
+     TUint32 timeValue( 0 );
+    // value of a timer, expressed using
+    // the format hour, minute, second
+    // Semi-octec presentation used (23.040)
+    // time[0] is hours
+    // time[1] is minutes
+    // time[2] is seconds
+     TInt i( 0 );
+    for ( i = 0; i < 3; i++ )
+        {
+        TUint value = ( time[i] & 0x0F )*10 + ( ( time[i] & 0xF0 ) >> 4 );
+        timeValue = timeValue * 60 + value;
+        }
+    return timeValue;
+
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoreTime::CSatNotifyMoreTime
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyMoreTime::CSatNotifyMoreTime
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::CSatNotifyMoreTime" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoreTime::~CSatNotifyMoreTime
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyMoreTime::~CSatNotifyMoreTime()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::~CSatNotifyMoreTime" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoreTime::MessageReceived
+// Handles a MoreTime proactive command ISI message,
+// Etel SAT request not required.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyMoreTime::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_MESSAGERECEIVED, "CSatNotifyMoreTime::MessageReceived" );
+    TFLOGSTRING("CSatNotifyMoreTime::MessageReceived");
+    //get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    //get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iSatMessHandler->MoreTimeTerminalResp(
+                        aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ),
+                        iCommandDetails,
+                        RSat::KSuccess );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoreTime::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a MoreTime PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyMoreTime::Notify
+        (
+        const TTsyReqHandle /*aReqHandle*/, // Request handle
+        TDes8*              /*aDataPtr*/    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_NOTIFY, "CSatNotifyMoreTime::Notify" );
+    // MoreTime is completely implemented by SimAtkTsy. Client
+    // insn't notified about the command.
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLanguageNotification::CSatNotifyLanguageNotification
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLanguageNotification::CSatNotifyLanguageNotification
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iLanguageNotificationV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::CSatNotifyLanguageNotification" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLanguageNotification::MessageReceived
+// Handles a LanguageNotification proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLanguageNotification::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived" );
+    TFLOGSTRING("TSY: CSatNotifyLanguageNotification::MessageReceived");
+    TInt ret( KErrNone );
+    TInt returnValue( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    returnValue = berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if( !iReqHandle )
+        {
+        iSatMessHandler->LanguageNotificationTerminalResp(
+                            iTransId,
+                            iCommandDetails,
+                            RSat::KMeUnableToProcessCmd,
+                            KNoCause ); // KNoCause: 0
+        }
+    else
+        {
+
+        RSat::TLanguageNotificationV2& languageNotificationV2 =
+                                    ( *iLanguageNotificationV2Pckg )();
+        // Command number
+        languageNotificationV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Initialisate
+        languageNotificationV2.iNotificationType = RSat::ENotificationTypeNotSet;
+        // Get command qualifier
+        TUint8 cmdQualifier(
+            commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+        if ( !cmdQualifier )
+           {
+            // No specific language used
+            languageNotificationV2.iNotificationType =
+                RSat::ENonSpecificLangNotification;
+            }
+        else if ( KSpecificLanguage == cmdQualifier )
+            {
+            // Currently used language
+            languageNotificationV2.iNotificationType =
+                RSat::ESpecificLangNotification;
+            }
+        else
+            {
+            TFLOGSTRING("TSY: \
+            CSatNotifyLanguageNotification::MessageReceived, \
+            Command qualifier did not match.");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived, Command qualifier did not match." );
+            }
+        CTlv language;
+        returnValue = berTlv.TlvByTagValue( &language,
+            KTlvLanguageTag );
+        // If the Language tag is found
+        if ( KErrNone == returnValue )
+            {
+            languageNotificationV2.iLanguage = language.GetLongInfo( ETLV_Language );
+            }
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLanguageNotification::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a LanguageNotification PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyLanguageNotification::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_NOTIFY, "CSatNotifyLanguageNotification::Notify" );
+    TFLOGSTRING("CSatNotifyLanguageNotification::Notify");
+    iReqHandle = aReqHandle;
+    iLanguageNotificationV2Pckg =
+        static_cast< RSat::TLanguageNotificationV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KLanguageNotification );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyLanguageNotification::TerminalResponse
+// Handles a LanguageNotification terminal response provided by an ETel SAT
+// client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyLanguageNotification::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_TERMINALRESPONSE, "CSatNotifyLanguageNotification::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyLanguageNotification::TerminalResponse");
+    TUint8 additionalInfo( 0 );
+    RSat::TLanguageNotificationRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TLanguageNotificationRspV2Pckg* >( aRsp );
+    RSat::TLanguageNotificationRspV2& rspV1 = ( *aRspPckg ) ();
+    iSatMessHandler->LanguageNotificationTerminalResp(
+                            iTransId,
+                            iCommandDetails,
+                            rspV1.iGeneralResult,
+                            additionalInfo );
+
+    return iAllowedResults == rspV1.iGeneralResult ? KErrNone : KErrCorrupt;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::CSatNotifyOpenChannel
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyOpenChannel::CSatNotifyOpenChannel
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iOpenBaseChannelV2Pckg( NULL ),
+        iOpenCsChannelV2Pckg( NULL ),
+        iOpenGprsChannelV4Pckg( NULL ),
+        iOpenLocalLinksChannelV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::CSatNotifyOpenChannel" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPerformedWithModifications+ RSat::KPSessionTerminatedByUser
+        + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser
+        + RSat::KInteractionWithCCTemporaryError
+        + RSat::KErrorRequiredValuesMissing + RSat::KBearerIndepProtocolError
+        + RSat::KAccessTechUnableProcessCmd;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::~CSatNotifyOpenChannel
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyOpenChannel::~CSatNotifyOpenChannel()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::~CSatNotifyOpenChannel" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::MessageReceived
+// Handles a OpenChannel proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyOpenChannel::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage // ISI message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived" );
+    TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived");
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Request Off");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Request Off" );
+        // Request not on, returning response immediately
+        TBuf8<1> noBearer( 0 );
+        TBuf8<1> noAdditionalInfo( 0 );
+        TUint16 noBufferSize( 0 );
+        iSatMessHandler->OpenChannelTerminalResp(
+             iTransId,
+             iCommandDetails,
+             RSat::KMeUnableToProcessCmd,
+             noAdditionalInfo,
+             TUint8( RSat::EBearerTypeNotSet ),
+             noBearer,
+             noBufferSize );
+        ret = KErrCorrupt;
+        }
+    else
+        {
+        RSat::TOpenChannelBaseV2& openChannelV2
+            = ( *iOpenBaseChannelV2Pckg ) ();
+
+        // Bearer Description & Buffer Size ( Mandatory )
+        CTlv bearerDescriptionTlv;
+        CTlv bufferSizeTlv;
+
+        if ( KErrNone == berTlv.TlvByTagValue( &bearerDescriptionTlv,
+             KTlvBearerDescriptionTag )
+            && KErrNone == berTlv.TlvByTagValue( &bufferSizeTlv,
+             KTlvBufferSizeTag ) )
+            {
+            // Command details
+            openChannelV2.SetPCmdNumber(
+                commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+
+            // Link Establishment, obtained
+            // from Command details Bit 1
+            // Get command qualifier
+            TUint8 cmdQualifier( commandDetails.GetShortInfo(
+                ETLV_CommandQualifier ) );
+            if ( KLinkEstablishmentMask & cmdQualifier )
+                {
+                openChannelV2.iLinkEst = RSat::EImmediate;
+                }
+            else
+                {
+                openChannelV2.iLinkEst = RSat::EOnDemand;
+                }
+
+            // Reconnection mode, obtained from Command
+            // details Bit 2
+            if ( KReconnectionModeMask & cmdQualifier )
+                {
+                openChannelV2.iReconnectionMode =
+                    RSat::EAutomaticReconnection;
+                }
+            else
+                {
+                openChannelV2.iReconnectionMode =
+                    RSat::ENoAutomaticReconnection;
+                }
+
+            // Buffer size
+            openChannelV2.iBufferSize = bufferSizeTlv.GetLongInfo(
+                ETLV_BufferSize );
+
+            // Handling of
+            // Bearer type
+            // Bearer parameters
+            GetBearerTypeAndParams( bearerDescriptionTlv,
+                openChannelV2.iBearer );
+
+            // Alpha Identifier ( Optional )
+            TPtrC8 sourceString; // Used with conversions
+            CTlv alphaIdentifierTlv;
+            // Get Alpha Identifier tlv from berTlv
+            TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifierTlv,
+                KTlvAlphaIdentifierTag ) );
+            // If Alpha Identifier string exist
+            if ( KErrNone == returnValue )
+                {
+                if ( alphaIdentifierTlv.GetLength() )
+                    {
+                    // 8-bit string to 16-bit string
+                    sourceString.Set(
+                        alphaIdentifierTlv.GetData( ETLV_AlphaIdentifier ) );
+                    // Convert and set the Alpha Identifier
+                    TSatUtility::SetAlphaId(
+                        sourceString, openChannelV2.iAlphaId.iAlphaId );
+                    // Set Alpha Identifier status
+                    openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+            // Alpha Identifier not present
+            else
+                {
+                openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+                }
+
+            // Icon Identifier ( optional )
+            TSatUtility::FillIconStructure( berTlv,
+                openChannelV2.iIconId );
+
+            // Handling of
+            // SIM/ME interface transport level ( Optional )
+            // Other Address - Set Destination Address
+            TInt retValueLocalAdd = SimMeInterfaceAndDataDestinationAddress(
+                berTlv,
+                openChannelV2.iSimMeInterface,
+                openChannelV2.iDestinationAddress );
+
+            // Switch according to bearer type
+            //
+            switch ( openChannelV2.iBearer.iType )
+                {
+                case RSat::EGPRSBearer:
+                    {
+                    TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - GPRS Bearer");
+                    OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - GPRS Bearer" );
+                    // Fill in TOpenGprsChannelV4
+                    RSat::TOpenGprsChannelV4& openGprsChannelV4
+                        = ( *iOpenGprsChannelV4Pckg )();
+                    openGprsChannelV4
+                        = static_cast<RSat::TOpenGprsChannelV4&>( openChannelV2 );
+                    openGprsChannelV4.iPCmdType = RSat::EGprsBearer;
+
+                    // Handling of
+                    // Other Address - Local Address ( Optional )
+                    if ( KErrNone == retValueLocalAdd )
+                        {
+                        LocalAddress( berTlv, openGprsChannelV4.iLocalAddress );
+                        }
+                    else
+                        {
+                        TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived -\
+                            Local Adress - not present");
+                        OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Local Adress - not present" );
+                        openGprsChannelV4.iLocalAddress.iType =
+                            RSat::EAddressNotPresent;
+                        }
+
+                    // Handling GPRS bearer specific data
+                    //
+                    // Network Access Point Name ( Optional )
+                    // Text string - User Login ( Optional )
+                    // Text string - User Password ( Optional )
+                    GprsBearerSpecific( berTlv, openGprsChannelV4 );
+                    break;
+                    }
+                case RSat::EDefaultBearer:
+                    {
+                    TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Default Bearer");
+                    OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Default Bearer" );
+                    // Fill in TOpenChannelBaseV2
+                    openChannelV2.iPCmdType = RSat::EAnyBearer;
+                    break;
+                    }
+                case RSat::ECSDBearer:
+                case RSat::EBTBearer:
+                case RSat::EIrDaBearer:
+                case RSat::ERS232Bearer:
+                case RSat::EUSBBearer:
+                    {
+                    TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported");
+                    OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
+                    // Bearer not supported
+                    TBuf8<1> noAdditionalInfo( 0 );
+                    iSatMessHandler->OpenChannelTerminalResp(
+                         iTransId,
+                         iCommandDetails,
+                         RSat::KCmdBeyondMeCapabilities,
+                         noAdditionalInfo,
+                         openChannelV2.iBearer.iType,
+                         openChannelV2.iBearer.iParams,
+                         openChannelV2.iBufferSize );
+                    ret = KErrCorrupt;
+                    break;
+                    }
+                default:
+                    {
+                    // Bearer not supported (RFU)
+                    TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported");
+                    OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
+                    // Required values missing
+                    TBuf8<1> noBearer( 0 );
+                    TBuf8<1> noAdditionalInfo( 0 );
+                    TUint16 noBufferSize( 0 );
+                    iSatMessHandler->OpenChannelTerminalResp(
+                         iTransId,
+                         iCommandDetails,
+                         RSat::KCmdDataNotUnderstood,
+                         noAdditionalInfo,
+                         TUint8( RSat::EBearerTypeNotSet ),
+                         noBearer,
+                         noBufferSize );
+                    ret = KErrCorrupt;
+                    break;
+                    }
+                } // End of switch according to bearer type
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Required values missing");
+            OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Required values missing" );
+            // Required values missing
+            TBuf8<1> noBearer( 0 );
+            TBuf8<1> noAdditionalInfo( 0 );
+            TUint16 noBufferSize( 0 );
+            iSatMessHandler->OpenChannelTerminalResp(
+                 iTransId,
+                 iCommandDetails,
+                 RSat::KErrorRequiredValuesMissing,
+                 noAdditionalInfo,
+                 TUint8( RSat::EBearerTypeNotSet ),
+                 noBearer,
+                 noBufferSize );
+            ret = KErrCorrupt;
+            } // End of Bearer Description & Buffer Size ( Mandatory )
+
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a OpenChannel PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyOpenChannel::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_NOTIFY, "CSatNotifyOpenChannel::Notify" );
+    TFLOGSTRING("CSatNotifyOpenChannel::Notify");
+    iReqHandle = aReqHandle;
+    iOpenBaseChannelV2Pckg =
+        static_cast< RSat::TOpenChannelBaseV2Pckg* >( aDataPtr );
+    iOpenCsChannelV2Pckg =
+        static_cast< RSat::TOpenCsChannelV2Pckg* >( aDataPtr );
+    iOpenGprsChannelV4Pckg =
+        static_cast< RSat::TOpenGprsChannelV4Pckg* >( aDataPtr );
+    iOpenLocalLinksChannelV2Pckg =
+        static_cast< RSat::TOpenLocalLinksChannelV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KOpenChannel );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::TerminalResponse
+// Handles a OpenChannel terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyOpenChannel::TerminalResponse
+        (
+        TDes8* aRsp // Response
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_TERMINALRESPONSE, "CSatNotifyOpenChannel::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyOpenChannel::TerminalResponse");
+    TInt   ret( KErrNone );
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+    additionalInfo.Zero();
+    RSat::TOpenChannelRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TOpenChannelRspV2Pckg* >( aRsp );
+    RSat::TOpenChannelRspV2& rspV2 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    // Check fo additional info type
+    // - If there is Me (Mobile Equipment) error, additional info is needed
+    // - Channel Status Info is sent through additional info
+    if ( ( RSat::KMeProblem == rspV2.iInfoType )
+        || ( RSat::KChannelStatusInfo == rspV2.iInfoType )
+        )
+        {
+        // Check the length of additional info
+        if ( !rspV2.iAdditionalInfo.Length() )
+            {
+            // Invalid additional info field
+            ret = KErrCorrupt;
+            }
+        else
+            {
+            TIsiUtility::CopyToBigEndian( rspV2.iAdditionalInfo, additionalInfo );
+            }
+        }
+    // Send Terminal Response
+    iSatMessHandler->OpenChannelTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV2.iGeneralResult ),
+        additionalInfo,
+        TUint8( rspV2.iBearer.iType ),
+        rspV2.iBearer.iParams,
+        rspV2.iBufferSize);
+    return ret;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::GetBearerTypeAndParams
+// Handles a OpenChannel Bearer type and parameters specific data.
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyOpenChannel::GetBearerTypeAndParams
+        (
+        CTlv& aBearerDescriptionTlv,
+        RSat::TBearer& aBearer
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GETBEARERTYPEANDPARAMS, "CSatNotifyOpenChannel::GetBearerTypeAndParams" );
+    TFLOGSTRING("TSY: CSatNotifyOpenChannel::GetBearerTypeAndParams");
+    TUint8 bearerType( aBearerDescriptionTlv.GetShortInfo( ETLV_BearerType ) );
+
+    // Switch for setting bearer type values
+    switch( bearerType )
+        {
+        case KBipCsdBearer:
+            {
+            aBearer.iType = RSat::ECSDBearer;
+            break;
+            }
+        case KBipGprsBearer:
+            {
+            aBearer.iType = RSat::EGPRSBearer;
+            break;
+            }
+        case KBipDefaultBearer:
+            {
+            aBearer.iType = RSat::EDefaultBearer;
+            break;
+            }
+        case KBipBluetoothBearer:
+            {
+            aBearer.iType = RSat::EBTBearer;
+            break;
+            }
+        case KBipIrDABearer:
+            {
+            aBearer.iType = RSat::EIrDaBearer;
+            break;
+            }
+        case KBipRS232Bearer:
+            {
+            aBearer.iType = RSat::ERS232Bearer;
+            break;
+            }
+        case KBipUSBBearer:
+            {
+            aBearer.iType = RSat::EUSBBearer;
+            break;
+            }
+        // Currently Local link technology independent bearer type is missing from
+        // Etel SAT API ( EtelSat.h)
+        case KBipLocalLinkTechnologyIndependentBearer:
+        default:
+            {
+            aBearer.iType = RSat::EBearerTypeNotSet;
+            break;
+            }
+        }
+
+    // Bearer parameters
+    aBearer.iParams = aBearerDescriptionTlv.GetData( ETLV_BearerParameters );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress
+// Handles a OpenChannel SIM/ME Interface transport level and Data Destination
+// Address specific data.
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress
+        (
+        CBerTlv& aBerTlv,
+        RSat::TSimMeInterface& aSimMeInterface,
+        RSat::TOtherAddress& aDestinationAddress
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress" );
+    TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress");
+
+    // SIM/ME Interface transport level ( Optional )
+    CTlv simMeInterfaceTlv;
+
+    if ( KErrNone == aBerTlv.TlvByTagValue( &simMeInterfaceTlv,
+        KTlvSimMeTransportLevelTag ) )
+        {
+        TFLOGSTRING("CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
+            SIM/ME Interface");
+        OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - SIM/ME Interface" );
+
+        aSimMeInterface.iPrtNumber = simMeInterfaceTlv.GetLongInfo(
+            ETLV_PortNumber );
+        TUint8 protocol( simMeInterfaceTlv.GetShortInfo(
+            ETLV_TransportProtocolType ) );
+
+        if ( KProtocolUdp == protocol )
+            {
+            aSimMeInterface.iTransportProto = RSat::EUdp;
+            }
+        else if ( KProtocolTcp == protocol )
+            {
+            aSimMeInterface.iTransportProto = RSat::ETcp;
+            }
+        else
+            {
+            aSimMeInterface.iTransportProto = RSat::EProtocolNotSet;
+            }
+        }
+    else
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
+            SIM/ME Interface - Not present");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -SIM/ME Interface - Not present" );
+        aSimMeInterface.iTransportProto = RSat::EProtocolNotPresent;
+        }
+
+    // Data destination address
+    // The Data Destination Address is the end point destination
+    // address of sent data. This data destination address is
+    // requested when a SIM/ME Interface transport is present,
+    // otherwise it is ignored.
+
+    // Determine the number of Other Address tags.
+    // - If there is one and no SIM/ME Interface then this is a Local Address.
+    // - If there is one and SIM/ME Interface, this is a Destination Address.
+    // - If there are two and SIM/ME Interface, then the last one is
+    //   the Destination Address.
+    CTlv* dataDestAddressTlv = NULL;
+    CTlv localAddress1;
+    CTlv localAddress2;
+
+    TInt retValueLocalAdd( KErrNotFound );
+    TInt retValAddr1( aBerTlv.TlvByTagValue( &localAddress1,
+        KTlvOtherAddressTag ) );
+    TInt retValAddr2( aBerTlv.TlvByTagValue( &localAddress2,
+        KTlvOtherAddressTag, 1 ) );
+
+    if ( ( RSat::EProtocolNotPresent !=
+           aSimMeInterface.iTransportProto )
+         && ( KErrNone == retValAddr1 )
+         && ( KErrNotFound == retValAddr2 ) )
+        {
+        // Destination Address is localAddress1
+        dataDestAddressTlv = &localAddress1;
+        // There can not be a Local Address
+        }
+    else if ( ( RSat::EProtocolNotPresent !=
+           aSimMeInterface.iTransportProto )
+         && ( KErrNone == retValAddr1 )
+         && ( KErrNone == retValAddr2 ) )
+        {
+        // Local Address is localAddress1
+        retValueLocalAdd = retValAddr1;
+        // Destination Address is localAddress2
+        dataDestAddressTlv = &localAddress2;
+        }
+    else if ( ( RSat::EProtocolNotPresent ==
+           aSimMeInterface.iTransportProto )
+         && ( KErrNone == retValAddr1 ) )
+        {
+        // There is only a Local Address
+        // Local Address is localAddress1
+        retValueLocalAdd = retValAddr1;
+        }
+    else
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress,\
+            Transport protocol did not match.");
+        OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress, Transport protocol did not match." );
+        }
+
+    // Other Address - Set Destination Address
+    if( dataDestAddressTlv )
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
+            Destination Address");
+        OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address" );
+        TUint8 typeOfAddress( dataDestAddressTlv->GetShortInfo(
+            ETLV_TypeOfAddress ) );
+        switch( typeOfAddress )
+            {
+            case KIPV4: // IPv4
+                {
+                aDestinationAddress.iType = RSat::EIPv4Address;
+                break;
+                }
+            case KIPV6: // IPv6
+                {
+                aDestinationAddress.iType = RSat::EIPv6Address;
+                break;
+                }
+            default:
+                {
+                aDestinationAddress.iType = RSat::EAddressNotSet;
+                break;
+                }
+            }
+        // Is there an address
+        if( dataDestAddressTlv->GetLength() - 1 )
+            {
+            aDestinationAddress.iAddress =
+                dataDestAddressTlv->GetData( ETLV_Address );
+            }
+        }
+    else
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
+            Destination Address - Not present");
+        OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address - Not present" );
+        aDestinationAddress.iType = RSat::EAddressNotPresent;
+        } // End of Other Address - Set Destination Address
+
+    return retValueLocalAdd;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::LocalAddress
+// Handles a OpenChannel Local Address specific data.
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyOpenChannel::LocalAddress
+        (
+        CBerTlv& aBerTlv,
+        RSat::TOtherAddress& aLocalAddress
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress" );
+    TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress");
+
+    // Other Address - Set Local Address ( Optional )
+    CTlv localAddressTlv;
+
+    if ( KErrNone == aBerTlv.TlvByTagValue( &localAddressTlv,
+        KTlvOtherAddressTag ) )
+        {
+        // If Other local address present
+        if ( localAddressTlv.GetLength() )
+            {
+            aLocalAddress.iAddress = localAddressTlv.GetData( ETLV_Address );
+            // Type of address
+            TUint8 typeOfAddress( localAddressTlv.GetShortInfo(
+                ETLV_TypeOfAddress ) );
+
+            if ( KIPV4 == typeOfAddress )
+                {
+                aLocalAddress.iType = RSat::EIPv4Address;
+                }
+            else if ( KIPV6 == typeOfAddress )
+                {
+                aLocalAddress.iType = RSat::EIPv6Address;
+                }
+            else
+                {
+                aLocalAddress.iType = RSat::EAddressNotSet;
+                }
+            }
+        else
+            {
+            TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress - not present");
+            OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress - not present" );
+            aLocalAddress.iType = RSat::EAddressNotPresent;
+            } // End of If Other local address present
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyOpenChannel::GprsBearerSpecific
+// Handles a OpenChannel GPRS bearer specific data.
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyOpenChannel::GprsBearerSpecific
+        (
+        CBerTlv& aBerTlv,
+        RSat::TOpenGprsChannelV4& aOpenGprsChannelV4
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific" );
+    TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific");
+
+    // Network Access Point Name ( Optional )
+    CTlv nanTlv;
+    // If Network Access Point Name present
+    if ( KErrNone == aBerTlv.TlvByTagValue( &nanTlv,
+        KTlvNetworkAccessNameTag ) )
+        {
+        TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific -\
+            Access Point name");
+        OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific - Access Point name" );
+        aOpenGprsChannelV4.iAccessName =
+            nanTlv.GetData( ETLV_NetworkAccessName );
+        }
+
+    // Text string - User Login ( Optional )
+    // Text string - User Password ( Optional )
+    TSatUtility::SetUserLoginAndUserPassword( aBerTlv,
+        aOpenGprsChannelV4.iUserLogin,
+        aOpenGprsChannelV4.iUserPassword );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iGetChannelStatusRspV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KPSessionTerminatedByUser
+        + RSat::KErrorRequiredValuesMissing;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetChannelStatus::MessageReceived
+// Handles a GetChannelStatus proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetChannelStatus::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage    // Received isi-message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_MESSAGERECEIVED, "CSatNotifyGetChannelStatus::MessageReceived" );
+    TFLOGSTRING("CSatNotifyGetChannelStatus::MessageReceived");
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details TLV
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        TBuf8<1> empty(0);
+        iSatMessHandler->GetChannelStatusTerminalResp( iTransId,
+                                                       iCommandDetails,
+                                                       RSat::KMeUnableToProcessCmd,
+                                                       empty );
+        }
+    else
+        {
+        // Fill the Get Channel status structure
+        RSat::TGetChannelStatusV2& channelStatusV2 =
+            ( *iGetChannelStatusRspV2Pckg )();
+        // Store transaction ID
+        channelStatusV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Complete request
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetChannelStatus::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a GetChannelStatus PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyGetChannelStatus::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_NOTIFY, "CSatNotifyGetChannelStatus::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyGetChannelStatus::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iGetChannelStatusRspV2Pckg =
+        static_cast< RSat::TGetChannelStatusV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KGetChannelStatus );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyGetChannelStatus::TerminalResponse
+// Handles a GetChannelStatus terminal response provided by an ETel SAT client
+// via ETel server,
+// transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyGetChannelStatus::TerminalResponse
+        (
+        TDes8* aRsp     // Response package
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_TERMINALRESPONSE, "CSatNotifyGetChannelStatus::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyGetChannelStatus::TerminalResponse");
+    TInt   ret( KErrNone );
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+    additionalInfo.Zero();
+    RSat::TGetChannelStatusRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TGetChannelStatusRspV2Pckg* >( aRsp );
+    RSat::TGetChannelStatusRspV2& rspV2 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    if ( ( RSat::KChannelStatusInfo == rspV2.iInfoType )
+        || ( RSat::KMeProblem == rspV2.iInfoType ) )
+        {
+        if( !rspV2.iAdditionalInfo.Length()
+            && rspV2.iAdditionalInfo.Length())
+            {
+            ret = KErrCorrupt;
+            }
+        else
+            {
+            TIsiUtility::CopyToBigEndian( rspV2.iAdditionalInfo, additionalInfo );
+            }
+        }
+    iSatMessHandler->GetChannelStatusTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV2.iGeneralResult ),
+        additionalInfo );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCloseChannel::CSatNotifyCloseChannel
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyCloseChannel::CSatNotifyCloseChannel
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iCloseChannelRspV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::CSatNotifyCloseChannel" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing
+        + RSat::KBearerIndepProtocolError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCloseChannel::~CSatNotifyCloseChannel
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyCloseChannel::~CSatNotifyCloseChannel()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::~CSatNotifyCloseChannel" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCloseChannel::MessageReceived
+// Handles a CloseChannel proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCloseChannel::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage    // Received isi-message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_MESSAGERECEIVED, "CSatNotifyCloseChannel::MessageReceived" );
+    TFLOGSTRING("CSatNotifyCloseChannel::MessageReceived");
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details TLV
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        TBuf8<1> empty(0);
+        iSatMessHandler->CloseChannelTerminalResp( iTransId,
+                                                    iCommandDetails,
+                                                    RSat::KMeUnableToProcessCmd,
+                                                    empty );
+        }
+    else
+        {
+        // Fill the Close Channel structure
+        RSat::TCloseChannelV2& closeChannelV2 =
+            ( *iCloseChannelRspV2Pckg )();
+        // Store transaction ID
+        closeChannelV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Store Channel Id
+        CTlv deviceIds;
+        TInt returnValue( berTlv.TlvByTagValue( &deviceIds,
+            KTlvDeviceIdentityTag ) );
+        if ( KErrNotFound != returnValue )
+            {
+            closeChannelV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo(
+                ETLV_DestinationDeviceIdentity );
+            }
+        // Alpha Id (Optional)
+        CTlv alphaIdentifier;
+        returnValue = berTlv.TlvByTagValue( &alphaIdentifier,
+            KTlvAlphaIdentifierTag ) ;
+        closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+        if ( KErrNotFound != returnValue )
+            {
+            TUint16 alphaIdLength = alphaIdentifier.GetLength();
+            if ( alphaIdLength )
+                {
+                // get the alpha id
+                TPtrC8 sourceString;
+                sourceString.Set(
+                    alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+                // convert and set the alpha id
+                TSatUtility::SetAlphaId( sourceString ,
+                    closeChannelV2.iAlphaId.iAlphaId );
+                }
+
+            // Set Alpha ID status
+            if ( closeChannelV2.iAlphaId.iAlphaId.Length() )
+                {
+                closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                }
+            else
+                {
+                closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                }
+            }
+        // Icon Id (Optional)
+        TSatUtility::FillIconStructure( berTlv,
+            closeChannelV2.iIconId );
+        // Complete request
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCloseChannel::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a CloseChannel PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyCloseChannel::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_NOTIFY, "CSatNotifyCloseChannel::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyCloseChannel::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iCloseChannelRspV2Pckg =
+        static_cast< RSat::TCloseChannelV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KCloseChannel );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyCloseChannel::TerminalResponse
+// Handles a CloseChannel terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyCloseChannel::TerminalResponse
+        (
+        TDes8* aRsp     // Response package
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_TERMINALRESPONSE, "CSatNotifyCloseChannel::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyCloseChannel::TerminalResponse");
+    TInt   ret( KErrNone );
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+    additionalInfo.Zero();
+    RSat::TCloseChannelRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TCloseChannelRspV2Pckg* >( aRsp );
+    RSat::TCloseChannelRspV2& rspV2 = ( *aRspPckg ) ();
+
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    if ( RSat::KMeProblem == rspV2.iInfoType )
+        {
+        if( rspV2.iAdditionalInfo.Length() )
+            {
+            additionalInfo.Append( TUint8( rspV2.iAdditionalInfo[0] ) );
+            }
+        else
+            {
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->CloseChannelTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV2.iGeneralResult ),
+        additionalInfo );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendData::CSatNotifySendData
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendData::CSatNotifySendData
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iSendDataRspV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::CSatNotifySendData" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KNetworkUnableToProcessCmd
+        + RSat::KErrorRequiredValuesMissing + RSat::KBearerIndepProtocolError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendData::~CSatNotifySendData
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifySendData::~CSatNotifySendData()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::~CSatNotifySendData" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendData::MessageReceived
+// Handles a SendData proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendData::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage    // Received isi-message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_MESSAGERECEIVED, "CSatNotifySendData::MessageReceived" );
+    TFLOGSTRING("CSatNotifySendData::MessageReceived");
+    // return value for completion of the request
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details TLV
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        TBuf8<1> empty(0);
+        TUint8 channelDataLength( 0 );
+        iSatMessHandler->SendDataTerminalResp(
+           iTransId,
+           iCommandDetails,
+           RSat::KMeUnableToProcessCmd,
+           empty,
+           channelDataLength );
+        }
+    else
+        {
+        // Fill the Send Data structure
+        RSat::TSendDataV2& sendDataV2 =
+            ( *iSendDataRspV2Pckg )();
+        // Store transaction ID
+        sendDataV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Store Channel Id
+        CTlv deviceIds;
+        if ( KErrNotFound != berTlv.TlvByTagValue( &deviceIds,
+            KTlvDeviceIdentityTag ) )
+            {
+            sendDataV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo(
+                ETLV_DestinationDeviceIdentity );
+            }
+        // Channel data (Mandatory)
+        // When the length is greater than 127, the byte 0x81 is appended before
+        // the actual length.
+        CTlv channelData;
+        if ( KErrNone == berTlv.TlvByTagValue( &channelData,
+             KTlvChannelDataTag ) )
+            {
+            // Set channel data
+            sendDataV2.iChannelData.Copy(
+                channelData.GetData( ETLV_ChannelDataString ) );
+            //Set Data mode using command qualifier
+            TUint8 cmdQualifier(
+                commandDetails.GetShortInfo( ETLV_CommandQualifier ) );
+            if ( KBipSendDataImmediately & cmdQualifier )
+                {
+                // bit 1 = 1
+                sendDataV2.iMode = RSat::ESendDataImmediately;
+                }
+            else
+                {
+                // bit 1 = 0
+                sendDataV2.iMode = RSat::EStoreDataInTxBuffer;
+                }
+            // Alpha Id (Optional)
+            sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            CTlv alphaIdentifier;
+            TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier,
+                KTlvAlphaIdentifierTag ) );
+            if ( KErrNotFound != returnValue )
+                {
+                TUint16 alphaIdLength = alphaIdentifier.GetLength();
+                if ( alphaIdLength )
+                    {
+                    // get the alpha id
+                    TPtrC8 sourceString;
+                    sourceString.Set(
+                        alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+                    // convert and set the alpha id
+                    TSatUtility::SetAlphaId( sourceString ,
+                        sendDataV2.iAlphaId.iAlphaId );
+                    sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+            // Icon Id (Optional)
+            TSatUtility::FillIconStructure( berTlv,
+                sendDataV2.iIconId );
+            }
+        else
+            {
+            // Required values missing
+            TBuf8<1> noAdditionalInfo( 0 );
+            TUint8 channelDataLength( 0 );
+            iSatMessHandler->SendDataTerminalResp(
+                 iTransId,
+                 iCommandDetails,
+                 RSat::KErrorRequiredValuesMissing,
+                 noAdditionalInfo,
+                 channelDataLength );
+            ret = KErrCorrupt;
+            }
+        // Complete request
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendData::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a SendData PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifySendData::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDATA_NOTIFY, "CSatNotifySendData::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifySendData::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iSendDataRspV2Pckg =
+        static_cast< RSat::TSendDataV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KSendData );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifySendData::TerminalResponse
+// Handles a SendData terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifySendData::TerminalResponse
+        (
+        TDes8* aRsp     // Response package
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_TERMINALRESPONSE, "CSatNotifySendData::TerminalResponse" );
+    TFLOGSTRING("CSatNotifySendData::TerminalResponse");
+    TInt   ret( KErrNone );
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+    additionalInfo.Zero();
+    RSat::TSendDataRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TSendDataRspV2Pckg* >( aRsp );
+    RSat::TSendDataRspV2& rspV2 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+
+    if ( RSat::KMeProblem == rspV2.iInfoType )
+        {
+        if( rspV2.iAdditionalInfo.Length() )
+            {
+            additionalInfo.Append( TUint8( rspV2.iAdditionalInfo[0] ) );
+            }
+        else
+            {
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->SendDataTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV2.iGeneralResult ),
+        additionalInfo,
+        rspV2.iChannelDataLength );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyReceiveData::CSatNotifyReceiveData
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyReceiveData::CSatNotifyReceiveData
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        )
+        :
+        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
+        iReceiveDataRspV2Pckg( NULL )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::CSatNotifyReceiveData" );
+    // Following results are also allowed for this command:
+    // (in addition to result declared in base class constructor)
+    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
+        + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing
+        + RSat::KBearerIndepProtocolError;
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyReceiveData::~CSatNotifyReceiveData
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyReceiveData::~CSatNotifyReceiveData()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::~CSatNotifyReceiveData" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyReceiveData::MessageReceived
+// Handles a ReceiveData proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyReceiveData::MessageReceived
+        (
+        const TIsiReceiveC& aIsiMessage    // Received isi-message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_MESSAGERECEIVED, "CSatNotifyReceiveData::MessageReceived" );
+    TFLOGSTRING("CSatNotifyReceiveData::MessageReceived");
+    // return value for completion of the request
+    TInt ret( KErrNone );
+    // Get ber tlv
+    CBerTlv berTlv;
+    berTlv.BerTlv( aIsiMessage );
+    // Get command details tlv
+    CTlv commandDetails;
+    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
+    // Store command details TLV
+    iCommandDetails.Copy( commandDetails.Data() );
+    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
+    if ( !iReqHandle )
+        {
+        // Request not on, returning response immediately
+        TBuf8<1> empty(0);
+        TUint8 channelDataLength( 0 );
+        iSatMessHandler->ReceiveDataTerminalResp( iTransId,
+                                                    iCommandDetails,
+                                                    RSat::KMeUnableToProcessCmd,
+                                                    empty,
+                                                    channelDataLength );
+        }
+    else
+        {
+        // Fill the Receive Data structure
+        RSat::TReceiveDataV2& receiveDataV2 =
+            ( *iReceiveDataRspV2Pckg )();
+        // Store transaction ID
+        receiveDataV2.SetPCmdNumber(
+            commandDetails.GetShortInfo( ETLV_CommandNumber ) );
+        // Store Channel Id
+        CTlv deviceIds;
+        if ( KErrNotFound != berTlv.TlvByTagValue( &deviceIds,
+            KTlvDeviceIdentityTag ) )
+            {
+            receiveDataV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo(
+                ETLV_DestinationDeviceIdentity );
+            }
+        // Channel data length (Mandatory)
+        CTlv channelDataLengthTlv;
+        if ( KErrNone == berTlv.TlvByTagValue( &channelDataLengthTlv,
+             KTlvChannelDataLengthTag ) )
+            {
+            receiveDataV2.iChannelDataLength =
+                channelDataLengthTlv.GetShortInfo( ETLV_ChannelDataLength );
+            // Alpha Id (Optional)
+            receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent;
+            CTlv alphaIdentifier;
+            TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier,
+                KTlvAlphaIdentifierTag ) );
+            if ( KErrNotFound != returnValue )
+                {
+                TUint16 alphaIdLength = alphaIdentifier.GetLength();
+                if ( alphaIdLength )
+                    {
+                    // get the alpha id
+                    TPtrC8 sourceString;
+                    sourceString.Set(
+                        alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
+                    // convert and set the alpha id
+                    TSatUtility::SetAlphaId( sourceString ,
+                        receiveDataV2.iAlphaId.iAlphaId );
+                    receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+                    }
+                else
+                    {
+                    receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdNull;
+                    }
+                }
+            // Icon Id (Optional)
+            TSatUtility::FillIconStructure( berTlv,
+                receiveDataV2.iIconId );
+            }
+        else
+            {
+            // Required values missing
+            TBuf8<1> noAdditionalInfo( 0 );
+            TUint8 channelDataLength( 0 );
+            iSatMessHandler->ReceiveDataTerminalResp(
+                 iTransId,
+                 iCommandDetails,
+                 RSat::KErrorRequiredValuesMissing,
+                 noAdditionalInfo,
+                 channelDataLength );
+            ret = KErrCorrupt;
+            }
+        // Complete request
+        CompleteRequest( ret );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyReceiveData::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a ReceiveData PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyReceiveData::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace1( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_NOTIFY, "CSatNotifyReceiveData::Notify Handle: %u", aReqHandle );
+    TFLOGSTRING2("CSatNotifyReceiveData::Notify. \n\t\t\t Handle:%d\n\t\t\t",
+               aReqHandle );
+    iReqHandle = aReqHandle;
+    iReceiveDataRspV2Pckg =
+        static_cast< RSat::TReceiveDataV2Pckg* >( aDataPtr );
+    iSatMessaging->SatReady( KReceiveData );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyReceiveData::TerminalResponse
+// Handles a ReceiveData terminal response provided by an ETel SAT client via
+// ETel server, transforms it into an ISI message, and passes it to domestic OS
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CSatNotifyReceiveData::TerminalResponse
+        (
+        TDes8* aRsp     // Response package
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_TERMINALRESPONSE, "CSatNotifyReceiveData::TerminalResponse" );
+    TFLOGSTRING("CSatNotifyReceiveData::TerminalResponse");
+    TInt   ret( KErrNone );
+    TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
+    additionalInfo.Zero();
+    RSat::TReceiveDataRspV2Pckg* aRspPckg =
+            reinterpret_cast< RSat::TReceiveDataRspV2Pckg* >( aRsp );
+    RSat::TReceiveDataRspV2& rspV2 = ( *aRspPckg ) ();
+    // Check that general result value is valid
+    if ( iAllowedResults != rspV2.iGeneralResult )
+        {
+        // Invalid general result
+        ret = KErrCorrupt;
+        }
+    if ( ( RSat::KMeProblem == rspV2.iInfoType )
+        || ( RSat::KChannelData == rspV2.iInfoType ) )
+        {
+        if( rspV2.iAdditionalInfo.Length() )
+            {
+            // Channel Data available and sent using Additional info
+            // Data are received in unicode format: 0x00XX where XX is
+            // meaningful.
+            additionalInfo.Copy( rspV2.iAdditionalInfo );
+            }
+        else
+            {
+            ret = KErrCorrupt;
+            }
+        }
+    iSatMessHandler->ReceiveDataTerminalResp(
+        iTransId,
+        iCommandDetails,
+        TUint8( rspV2.iGeneralResult ),
+        additionalInfo,
+        rspV2.iChannelDataLength );
+    return ret;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest
+        (
+        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
+        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
+        ) : CSatNotificationsBase( aSatMessHandler, aSatMessaging )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest" );
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest()
+    {
+    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest" );
+    // None
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoSmControlRequest::MessageReceived
+// Handles a MoSmControlRequest proactive command ISI message,
+// and completes a pending ETel request.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyMoSmControlRequest::MessageReceived
+        (
+        const TIsiReceiveC& /*aIsiMessage*/    // ISI  message
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyMoSmControlRequest::MessageReceived" );
+    // In S60 phones, the MoSm control request is received via an ISI
+    // message coming from the SMS server. That's why the body
+    // of this method is empty, see the class CSatMoSmCtrl. The Etel Sat API is used
+    // to pass to S60 Sat Server the alpha identifier provided by the SIM,
+    // if any. The SIM can provide such an alpha id to tell the user that the
+    // number to which the SMS has to be sent, has been modified by the SIM.
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoSmControlRequest::CompleteNotification
+// Completes an ETel server Mo-Sms Control notification
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyMoSmControlRequest::CompleteNotification
+        (
+        TDesC& aAlphaId,                // Alpha Id
+        RSat::TControlResult aResult    // Call Control result
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyMoSmControlRequest::CompleteNotification" );
+    TFLOGSTRING("CSatNotifyMoSmControlRequest::CompleteNotification");
+    //check that a client has requested this notifications
+    if ( iReqHandle )
+        {
+        // Fill the call control structure
+        RSat::TMoSmControlV1& moSmControlV1 = ( *iMoSmControlV1Pckg )();
+        // Set Alpha id status
+        if ( aAlphaId. Length() )
+            {
+            moSmControlV1.iAlphaId.iStatus = RSat::EAlphaIdProvided;
+            }
+        else
+            {
+            moSmControlV1.iAlphaId.iStatus = RSat::EAlphaIdNull;
+            }
+        //set control result
+        moSmControlV1.iResult = aResult;
+        // set alpha id
+        moSmControlV1.iAlphaId.iAlphaId.Append( aAlphaId );
+        //Complete notification
+        CompleteRequest( KErrNone );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CSatNotifyMoSmControlRequest::Notify
+// An ETel SAT client can call this method via ETel server to set a pending
+// request in SimAtkTsy for a MoSmControlRequest PCmd.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatNotifyMoSmControlRequest::Notify
+        (
+        const TTsyReqHandle aReqHandle, // Request handle
+        TDes8*              aDataPtr    // Pointer to data
+        )
+    {
+    OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_NOTIFY, "CSatNotifyMoSmControlRequest::Notify" );
+    TFLOGSTRING("CSatNotifyMoSmControlRequest::Notify");
+    iReqHandle = aReqHandle;
+    iMoSmControlV1Pckg = static_cast< RSat::TMoSmControlV1Pckg* >( aDataPtr );
+    }
+
+//  End of File