diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simatktsy/src/CSatNotifyOpenChannel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simatktsy/src/CSatNotifyOpenChannel.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,841 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// Name : CSatNotifyOpenChannel.cpp +// Part of : Common SIM ATK TSY / commonsimatktsy +// Open channel notification functionality of Sat Tsy +// Version : 1.0 +// + + + +//INCLUDES +#include // Etel SAT IPC definitions +#include "CSatTsy.h" // Tsy class header +#include "CSatNotifyOpenChannel.h" // Class header +#include "CSatNotificationsTsy.h" // Tsy class header +#include "CBerTlv.h" // Ber Tlv data handling +#include "TTlv.h" // TTlv class +#include "CSatDataPackage.h" // Parameter packing +#include "TfLogger.h" // For TFLOGSTRING +#include "TSatUtility.h" // Utilities +#include "CSatTsyReqHandleStore.h" // Request handle class +#include "cmmmessagemanagerbase.h" // Message manager class for forwarding req. + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CSatNotifyOpenChannel* CSatNotifyOpenChannel::NewL + ( + CSatNotificationsTsy* aNotificationsTsy + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::NewL"); + CSatNotifyOpenChannel* const satNotifyOpenChannel = + new ( ELeave ) CSatNotifyOpenChannel( aNotificationsTsy ); + CleanupStack::PushL( satNotifyOpenChannel ); + satNotifyOpenChannel->ConstructL(); + CleanupStack::Pop( satNotifyOpenChannel ); + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::NewL, end of method"); + return satNotifyOpenChannel; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::~CSatNotifyOpenChannel +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyOpenChannel::~CSatNotifyOpenChannel + ( + // None + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::~CSatNotifyOpenChannel"); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::CSatNotifyOpenChannel +// Default C++ constructor +// ----------------------------------------------------------------------------- +// +CSatNotifyOpenChannel::CSatNotifyOpenChannel + ( + CSatNotificationsTsy* aNotificationsTsy + ) : iNotificationsTsy ( aNotificationsTsy ), iBearerType( 0 ), + iBearer( 0 ), iBufferSize( 0 ) + { + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::ConstructL +// Symbian 2nd phase constructor +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::ConstructL + ( + // None + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::ConstructL"); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::Notify +// This request allows a client to be notified of a OPEN CHANNEL proactive +// command +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::Notify + ( + const TTsyReqHandle aTsyReqHandle, + const TDataPackage& aPackage + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::Notify"); + // Save data pointers to client side for completion + iOpenBaseChannelV2Pckg = reinterpret_cast( + aPackage.Des1n() ); + iOpenCsChannelV2Pckg = reinterpret_cast( + aPackage.Des1n() ); + iOpenGprsChannelV4Pckg = reinterpret_cast( + aPackage.Des1n() ); + iOpenLocalLinksChannelV2Pckg = reinterpret_cast< + RSat::TOpenLocalLinksChannelV2Pckg*>( aPackage.Des1n() ); + // Save the request handle + iNotificationsTsy->iSatTsy->SaveReqHandle( aTsyReqHandle, + CSatTsy::ESatNotifyOpenChannelPCmdReqType ); + // Check if requested notification is already pending + iNotificationsTsy->NotifySatReadyForNotification( KOpenChannel ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::CancelNotification +// This method cancels an outstanding asynchronous +// NotifyOpenChannel request. +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::CancelNotification + ( + const TTsyReqHandle aTsyReqHandle + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CancelNotification"); + + // Reset the request handle + TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore-> + ResetTsyReqHandle( CSatTsy::ESatNotifyOpenChannelPCmdReqType ); + // Reset the data pointers + iOpenCsChannelV2Pckg = NULL; + iOpenGprsChannelV4Pckg = NULL; + iOpenLocalLinksChannelV2Pckg = NULL; + // Complete the request with KErrCancel + iNotificationsTsy->iSatTsy->ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::CompleteNotifyL +// This method completes an outstanding asynchronous +// NotifyOpenChannel request. +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::CompleteNotifyL + ( + CSatDataPackage* aDataPackage, + TInt aErrorCode + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL"); + + TInt ret( KErrNone ); + // Unpack parameters + TPtrC8* data; + aDataPackage->UnPackData( &data ); + // Reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore-> + ResetTsyReqHandle( CSatTsy::ESatNotifyOpenChannelPCmdReqType ); + + // Get ber tlv + CBerTlv berTlv; + berTlv.SetData( *data ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iNotificationsTsy->iTerminalRespData.iCommandDetails.Copy( + commandDetails.Data() ); + // Get proactive command number + TUint8 pCmdNumber( commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + + // In case the request was ongoing, continue.. + if ( CSatTsy::ESatReqHandleUnknown != reqHandle ) + { + // Complete right away if error has occured, otherwise continue.. + if ( KErrNone == aErrorCode ) + { + RSat::TOpenChannelBaseV2* openChannelV2 = NULL; + + // Mandatory: Bearer Description & Buffer Size + CTlv bearerDescription; + CTlv bufferSize; + if ( KErrNone == berTlv.TlvByTagValue( + &bearerDescription, KTlvBearerDescriptionTag ) && + KErrNone == berTlv.TlvByTagValue( &bufferSize, + KTlvBufferSizeTag ) ) + { + // Switch according to bearer + switch ( bearerDescription.GetShortInfo( ETLV_BearerType ) ) + { + case KBipCsdBearer: + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Command not supported: \ + Csd Bearer"); + // Buffer size + iBufferSize = bufferSize.GetLongInfo( + ETLV_BufferSize ); + // Bearer description + iBearerType = RSat::ECSDBearer; + iBearer = bearerDescription.GetData( + ETLV_BearerParameters ); + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, BipCsdBearer "); + CreateTerminalRespL( pCmdNumber, + RSat::KCmdBeyondMeCapabilities, KNullDesC16 ); + ret = KErrCorrupt; + break; + } + case KBipGprsBearer: + { + // Fill in TOpenGprsChannelV4 + RSat::TOpenGprsChannelV4& openGprsChannelV4 + = ( *iOpenGprsChannelV4Pckg )(); + openChannelV2 = &openGprsChannelV4; + + openChannelV2->iPCmdType = RSat::EGprsBearer; + // Network access name (Optional) + CTlv nanTlv; + if ( KErrNone == berTlv.TlvByTagValue( &nanTlv, + KTlvNetworkAccessNameTag ) ) + { + openGprsChannelV4.iAccessName = + nanTlv.GetData( ETLV_NetworkAccessName ); + } + + // Text string (User Logging) + CTlv textStringUL; + TInt returnValue = berTlv.TlvByTagValue( + &textStringUL, KTlvTextStringTag ); + if ( KErrNone == returnValue ) + { + // Convert and set text + TSatUtility::SetText( textStringUL, + openGprsChannelV4.iUserLogin ); + } + + // Text string (User password) + CTlv textStringUP; + returnValue = berTlv.TlvByTagValue( &textStringUP, + KTlvTextStringTag, 1 ); + if ( KErrNone == returnValue ) + { + // Convert and set text + TSatUtility::SetText( textStringUP, + openGprsChannelV4.iUserPassword ); + } + break; + } + case KBipDefaultBearer: + { + // Fill in TOpenChannelBaseV2 + openChannelV2 = &( *iOpenBaseChannelV2Pckg )(); + openChannelV2->iPCmdType = RSat::EAnyBearer; + break; + } + case KBipLocalLinkBearer: + default: + { + // Bearer not supported (RFU) + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Bearer not supported"); + // Required values missing + iBearer.FillZ( 1 ); + iBufferSize = 0; + iBearerType = static_cast( + RSat::EBearerTypeNotSet ); + CreateTerminalRespL( pCmdNumber, + RSat::KCmdDataNotUnderstood, KNullDesC16 ); + ret = KErrCorrupt; + break; + } + } + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\ + required values missing"); + // Required values missing + iBearer.FillZ( 1 ); + iBufferSize = 0; + iBearerType = static_cast( RSat::EBearerTypeNotSet ); + CreateTerminalRespL( pCmdNumber, + RSat::KErrorRequiredValuesMissing, KNullDesC16 ); + ret = KErrCorrupt; + } + + if ( KErrNone == ret ) + { + // Buffer size + openChannelV2->iBufferSize = bufferSize.GetLongInfo( + ETLV_BufferSize ); + // Bearer description + openChannelV2->iBearer.iType = ( RSat::TBearerType ) + bearerDescription.GetShortInfo( ETLV_BearerType ); + openChannelV2->iBearer.iParams = bearerDescription.GetData( + ETLV_BearerParameters ); + // Proactive command number + openChannelV2->SetPCmdNumber( pCmdNumber ); + + // Link Establishment, obtained from Command details Bit 1 + // Get command qualifier + TUint8 cmdQualifier( commandDetails.GetShortInfo( + ETLV_CommandQualifier ) ); + if ( 0x01 & cmdQualifier ) + { + openChannelV2->iLinkEst = RSat::EImmediate; + } + else + { + openChannelV2->iLinkEst = RSat::EOnDemand; + } + // Reconnection mode, obtained from Command details Bit 2 + if ( 0x02 & cmdQualifier ) + { + openChannelV2->iReconnectionMode = + RSat::EAutomaticReconnection; + } + else + { + openChannelV2->iReconnectionMode = + RSat::ENoAutomaticReconnection; + } + + // Alpha Id (Optional) + TPtrC8 sourceString; // Used with conversions + 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, + openChannelV2->iAlphaId.iAlphaId ); + // Set alpha id status + openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Alpha ID is NULL"); + openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Alpha id not present + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\ + Alpha ID not present"); + openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + + + // Iconid (optional) + TSatUtility::FillIconStructure( berTlv, + openChannelV2->iIconId ); + + // SIM/ME interface transport level + CTlv simMeInterfaceTlv; + returnValue = berTlv.TlvByTagValue( &simMeInterfaceTlv, + KTlvSimMeTransportLevelTag ); + + if ( KErrNone == returnValue ) + { + openChannelV2->iSimMeInterface.iPrtNumber = + simMeInterfaceTlv.GetLongInfo( ETLV_PortNumber ); + TUint8 protocol = simMeInterfaceTlv.GetShortInfo( + ETLV_TransportProtocolType ); + + switch ( protocol ) + { + case 0x01: + { + openChannelV2->iSimMeInterface.iTransportProto = + RSat::EUdp; + break; + } + case 0x02: + { + openChannelV2->iSimMeInterface.iTransportProto = + RSat::ETcp; + break; + } + default: + { + openChannelV2->iSimMeInterface.iTransportProto = + RSat::EProtocolNotSet; + } + } + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\ + Protocol not present"); + openChannelV2->iSimMeInterface.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 + // But if there is one and SIM/ME interface, this is a + // Destination address, + // And if there are 2, then the last one is the destination + // address. + + CTlv* dataDestAddressTlv=NULL; + CTlv* localAddressTlv=NULL; + CTlv localAddress1; + CTlv localAddress2; + TInt ret_laddr1 = berTlv.TlvByTagValue( &localAddress1, + KTlvOtherAddressTag ); + TInt ret_laddr2 = berTlv.TlvByTagValue( &localAddress2, + KTlvOtherAddressTag, 1 ); + + if ( ( RSat::EProtocolNotPresent != + openChannelV2->iSimMeInterface.iTransportProto ) + && ( KErrNone == ret_laddr1 ) + && ( KErrNotFound == ret_laddr2 ) ) + { + // Destination Address is localAddress1, no local address + dataDestAddressTlv = &localAddress1; + } + else if ( ( RSat::EProtocolNotPresent != + openChannelV2->iSimMeInterface.iTransportProto ) + && ( KErrNone == ret_laddr1 ) + && ( KErrNone == ret_laddr2 ) ) + { + // Local address is localAddress1 + localAddressTlv = &localAddress1; + // Destination Address is localAddress2 + dataDestAddressTlv = &localAddress2; + } + else if ( ( RSat::EProtocolNotPresent == + openChannelV2->iSimMeInterface.iTransportProto ) + && ( KErrNone == ret_laddr1 ) ) + { + // There is only a local address, which is localAddress1 + localAddressTlv = &localAddress1; + } + + // Set Destination address + if( dataDestAddressTlv ) + { + TUint8 typeOfAddress = dataDestAddressTlv->GetShortInfo( + ETLV_TypeOfAddress ); + + switch( typeOfAddress ) + { + case KIPV4: // IPv4 + { + openChannelV2->iDestinationAddress.iType = + RSat::EIPv4Address; + break; + } + case KIPV6: // IPv6 + { + openChannelV2->iDestinationAddress.iType = + RSat::EIPv6Address; + break; + } + default: + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Address not set"); + openChannelV2->iDestinationAddress.iType = + RSat::EAddressNotSet; + break; + } + } + //Is there an address + if( dataDestAddressTlv->GetLength() - 1 ) + { + openChannelV2->iDestinationAddress.iAddress = + dataDestAddressTlv->GetData( ETLV_Address ); + } + } + else + { + openChannelV2->iDestinationAddress.iType = + RSat::EAddressNotPresent; + } + + // Set Local address (Other Address) + if ( localAddressTlv ) + { + CTlv bearerDescription; + if ( KErrNone == berTlv.TlvByTagValue( &bearerDescription, + KTlvBearerDescriptionTag ) ) + { + switch ( bearerDescription.GetShortInfo( + ETLV_BearerType ) ) + { + case KBipCsdBearer: + { + RSat::TOpenCsChannelV2& openCsChannelV2 + = ( *iOpenCsChannelV2Pckg )(); + openCsChannelV2.iLocalAddress.iAddress = + localAddressTlv->GetData( ETLV_Address ); + TUint8 typeOfAddress = localAddressTlv-> + GetShortInfo( ETLV_TypeOfAddress ); + + switch ( typeOfAddress ) + { + case KIPV4: + { + openCsChannelV2.iLocalAddress.iType = + RSat::EIPv4Address; + break; + } + case KIPV6: + { + openCsChannelV2.iLocalAddress.iType = + RSat::EIPv6Address; + break; + } + default: + { + TFLOGSTRING("CSAT:\ + CSatNotifyOpenChannel::\ + CompleteNotifyL, Address not set"); + openCsChannelV2.iLocalAddress.iType = + RSat::EAddressNotSet; + } + } + + // Is there an address + if( localAddressTlv->GetLength() - 1 ) + { + openCsChannelV2.iLocalAddress.iAddress = + localAddressTlv->GetData( ETLV_Address ); + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Address not present"); + openCsChannelV2.iLocalAddress.iType = + RSat::EAddressNotPresent; + } + + break; + } + case KBipGprsBearer: + { + RSat::TOpenGprsChannelV4& openGprsChannelV4 + = ( *iOpenGprsChannelV4Pckg )(); + openGprsChannelV4.iLocalAddress.iAddress = + localAddressTlv->GetData( ETLV_Address ); + TUint8 typeOfAddress = localAddressTlv-> + GetShortInfo( ETLV_TypeOfAddress ); + + switch ( typeOfAddress ) + { + case KIPV4: + { + openGprsChannelV4.iLocalAddress.iType = + RSat::EIPv4Address; + break; + } + case KIPV6: + { + openGprsChannelV4.iLocalAddress.iType = + RSat::EIPv6Address; + break; + } + default: + { + TFLOGSTRING("CSAT: \ + CSatNotifyOpenChannel::\ + CompleteNotifyL, Address not set"); + openGprsChannelV4.iLocalAddress.iType = + RSat::EAddressNotSet; + } + } + + // Is there an address + if( localAddressTlv->GetLength() - 1 ) + { + openGprsChannelV4.iLocalAddress.iAddress = + localAddressTlv->GetData( + ETLV_Address ); + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Address not present"); + openGprsChannelV4.iLocalAddress.iType = + RSat::EAddressNotPresent; + } + + break; + } + default: + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\ + CompleteNotifyL, Unknown Bearer type"); + break; + } + + } // Switch-case + } // If bearer description tag exists + } // if ( localAddressTlv ) + } // if ( KErrNone == ret ) + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\ + Error when parsing Bearer data"); + } + } // if ( KErrNone == aErrorCode ) + else + { + ret = aErrorCode; + } + + iNotificationsTsy->iSatTsy->ReqCompleted( reqHandle, ret ); + } // if ( CSatTsy::ESatReqHandleUnknown != reqHandle ) + else + { + // Request not on, returning response immediately + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL, \ + Request not ongoing"); + // additional info must be provided with KMeUnableToProcessCmd + TBuf16<1> additionalInfo; + additionalInfo.Append( RSat::KNoSpecificMeProblem ); + iBearer.FillZ( 1 ); + iBufferSize = 0; + iBearerType = static_cast( RSat::EBearerTypeNotSet ); + CreateTerminalRespL( pCmdNumber, RSat::KMeUnableToProcessCmd, + additionalInfo ); + ret = KErrCorrupt; + } + return ret; + } +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::TerminalResponseL +// Called by ETel server, passes terminal response to DOS +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::TerminalResponseL + ( + TDes8* aRsp + ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL"); + + TInt ret( KErrNone ); + + TBuf16 additionalInfo; + + RSat::TOpenChannelRspV2Pckg* aRspPckg = + REINTERPRET_CAST( RSat::TOpenChannelRspV2Pckg*, aRsp); + RSat::TOpenChannelRspV2& rspV2 = ( *aRspPckg ) (); + + TUint8 pCmdNumber( rspV2.PCmdNumber() ); + + TFLOGSTRING2("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \ + General result: %d", rspV2.iGeneralResult); + + // Check that general result value is valid + if ( ( RSat::KSuccess != rspV2.iGeneralResult ) + && ( RSat::KPartialComprehension != rspV2.iGeneralResult ) + && ( RSat::KMissingInformation != rspV2.iGeneralResult ) + && ( RSat::KSuccessRequestedIconNotDisplayed != rspV2.iGeneralResult ) + && ( RSat::KPerformedWithModifications != rspV2.iGeneralResult ) + && ( RSat::KRefreshUSIMNotActive != rspV2.iGeneralResult ) + && ( RSat::KPSessionTerminatedByUser != rspV2.iGeneralResult ) + && ( RSat::KMeUnableToProcessCmd != rspV2.iGeneralResult ) + && ( RSat::KNetworkUnableToProcessCmd != rspV2.iGeneralResult ) + && ( RSat::KPCmdNotAcceptedByUser != rspV2.iGeneralResult ) + && ( RSat::KInteractionWithCCTemporaryError != rspV2.iGeneralResult ) + && ( RSat::KCmdBeyondMeCapabilities != rspV2.iGeneralResult ) + && ( RSat::KCmdTypeNotUnderstood != rspV2.iGeneralResult ) + && ( RSat::KCmdDataNotUnderstood != rspV2.iGeneralResult ) + && ( RSat::KCmdNumberNotKnown != rspV2.iGeneralResult ) + && ( RSat::KErrorRequiredValuesMissing != rspV2.iGeneralResult ) + && ( RSat::KBearerIndepProtocolError != rspV2.iGeneralResult ) + && ( RSat::KAccessTechUnableProcessCmd != rspV2.iGeneralResult ) + && ( RSat::KFramesError != rspV2.iGeneralResult ) ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \ + Invalid General Result"); + // Invalid general result + ret = KErrCorrupt; + } + + // Check for 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() <= 0 ) + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \ + Invalid Additional Info"); + // Invalid additional info field + ret = KErrCorrupt; + } + else + { + additionalInfo.Copy(rspV2.iAdditionalInfo); + } + } + else if ( RSat::KSatNetworkErrorInfo == rspV2.iInfoType ) + { + // Copy the additional info, if present + if ( rspV2.iAdditionalInfo.Length() > 0 ) + { + additionalInfo.Copy(rspV2.iAdditionalInfo); + } + } + else if ( RSat::KNoAdditionalInfo == rspV2.iInfoType ) + { + // Do nothing + } + else + { + TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \ + Invalid Additional Info type"); + ret = KErrCorrupt; + } + + iBearerType = static_cast(rspV2.iBearer.iType); + iBearer.Copy( rspV2.iBearer.iParams ); + iBufferSize = rspV2.iBufferSize; + // Send Terminal Response + TInt response = CreateTerminalRespL( pCmdNumber, + static_cast( rspV2.iGeneralResult ), additionalInfo ); + + if ( KErrNone == ret ) + ret = response; + + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::CreateTerminalRespL +// Constructs Open channel specific part of terminal response and calls +// DOS to send the actual message. +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::CreateTerminalRespL + ( + TUint8 aPCmdNumber, + TUint8 aGeneralResult, + const TDesC16& aAdditionalInfo + ) + { + TFLOGSTRING("CSAT: CSatMessHandler::CreateTerminalRespL"); + // Create and append response data + TTlv tlvSpecificData; + // Create General Result TLV here + tlvSpecificData.AddTag( KTlvResultTag ); + // General result + tlvSpecificData.AddByte( aGeneralResult ); + + if ( ( RSat::KSuccess == aGeneralResult ) + || ( RSat::KPartialComprehension == aGeneralResult ) + || ( RSat::KMissingInformation == aGeneralResult ) + || ( RSat::KPerformedWithModifications == aGeneralResult ) + || ( RSat::KSuccessRequestedIconNotDisplayed == aGeneralResult ) ) + { + // Successful result: append Channel Status using additional info. + for ( TInt i = 1; i < aAdditionalInfo.Length(); i += 2 ) + { + tlvSpecificData.AddTag( KTlvChannelStatusTag ); + tlvSpecificData.AddByte( static_cast( aAdditionalInfo[i-1] ) ); + tlvSpecificData.AddByte( static_cast( aAdditionalInfo[i] ) ); + } + } + else + { + // Successful result: could/must provide an additional info byte + if ( aAdditionalInfo.Length() > 0 ) + { + TFLOGSTRING2("CSAT: CSatMessHandler::CreateTerminalRespL,\ + Unsuccessful result: aAddtionalInfo: %d", aAdditionalInfo[0]); + tlvSpecificData.AddByte( static_cast( aAdditionalInfo[0] ) ); + } + } + + // For any result: Append Bearer Description data + if ( iBearer.Length() ) + { + tlvSpecificData.AddTag( KTlvBearerDescriptionTag ); + tlvSpecificData.AddByte( iBearerType ); + tlvSpecificData.AddData( iBearer ); + } + else + { + TFLOGSTRING("CSAT: CSatMessHandler::CreateTerminalRespL: \ + No Bearer Description data available"); + } + + // Append Buffer Size + tlvSpecificData.AddTag( KTlvBufferSizeTag ); + tlvSpecificData.AddByte( TUint8( ( iBufferSize & 0xFF00 ) >> 8 ) ); + tlvSpecificData.AddByte( TUint8( iBufferSize & 0x00FF ) ); + + // Prepare data + iNotificationsTsy->iTerminalRespData.iPCmdNumber = aPCmdNumber; + TPtrC8 data = tlvSpecificData.GetDataWithoutTopLevelTag(); + + // Pack data + CSatDataPackage dataPackage; + dataPackage.PackData( &iNotificationsTsy->iTerminalRespData, &data ); + + // Forward request to the DOS + return iNotificationsTsy->iSatTsy->MessageManager()->HandleRequestL( + ESatTerminalRsp, &dataPackage ); + } + +// End of file +