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

equal deleted inserted replaced

-:510c70acdbf6
+:8ccc39f9d787
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
 #include "satmessaging.h"       // sat messaging class
 #include "satmesshandler.h"     // sat message handler class
 #include "ber_tlv.h"            // sat ber-tlv classes
 #include "satutil.h"            // sat utility class
+#include <satcs.h>
 #include <pn_const.h>           // server id constants
 #include <tisi.h>               // isi message
 #include <ss_wmisi.h>           // Modem SS server
 #include <call_modemisi.h>      // Modem Call server
 #include <gpdsisi.h>            // GPDS server
 #include <uiccisi.h>            // UICC server
-#include "osttracedefinitions.h"
+#include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
-#include "satcctraces.h"
+#include "satccTraces.h"
 #endif
 // CONSTANTS
 4 +     //CALL_MODEM_SB_MODE
 252 +   //CALL_MODEM_SB_BC
 252 +   //CALL_MODEM_SB_DESTINATION_ADDRESS
 252 +   //CALL_MODEM_SB_DESTINATION_SUBADDRESS
 252 +   //CALL_MODEM_SB_BC
+4 +     //CALL_MODEM_SB_CAUSE
 4;      //CALL_MODEM_SB_CAUSE
 const TUint8 KMSBMask = 0x80;
 //
 CSatCC::~CSatCC()
 {
 OstTrace0( TRACE_NORMAL, DUP1_CSATCC_CSATCC, "CSatCC::~CSatCC" );
 TFLOGSTRING("TSY: CSatCC::~CSatCC");
 if( iCallControlArray )
 {
 iCallControlArray->Close();
 delete iCallControlArray;
 }
 // SIM does not support USSD and converting it to SS was
 // impossible. Remove the created CcStruct from the CC array and
 // send CC event response.
 TPtrC8 atkData;
 SendSsResourceControlReq( aCcstruct, KError, atkData );
 TInt index( GetArrayIndexById( aCcstruct.iTransId ) );
 if ( index != KErrNotFound )
 {
 iCallControlArray->Remove( index );
 iCallControlArray->Compress();
 TInt retValue( aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
 CALL_MODEM_SB_DESTINATION_ADDRESS,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset ) );
 if ( KErrNone == retValue )
 {
 envelope.AddTag( KTlvAddressTag );
 envelope.AddByte( KMSBMask | aCallControl.iAddressType );
 // Unicode address must be converted to BCD number
 sbStartOffset );
 if ( KErrNone == retValue )
 {
 envelope.AddTag( KTlvSubaddressTag );
 // Subaddress is given in same form as expected in envelope
 addressLength = aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_DESTINATION_SUBADDRESS_OFFSET_ADDRLEN );
 envelope.AddData( aIsiMessage.GetData( sbStartOffset +
 CALL_MODEM_SB_DESTINATION_SUBADDRESS_OFFSET_ADDR,
 addressLength ) );
 }
 // Add mandatory location information
 AddLocationInformationToTlv( envelope );
 // send it away..
 AddLocationInformationToTlv( envelope );
 // send it away..
 return iSatMessHandler->UiccCatReqEnvelope( aPdpCcEnvelopeTid,
 envelope.End() );
 }
 // -----------------------------------------------------------------------------
 // CSatCC::UiccCatRespEnvelopeReceived
 // Handler function of incoming call control related data notification messages
 // -----------------------------------------------------------------------------
 }
 case CALL_MODEM_RESOURCE_CONF_IND:
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_IND");
 OstTrace0( TRACE_NORMAL, DUP1_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_IND" );
 if ( CALL_MODEM_RES_CONF_STARTUP ==
 aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_RESOURCE_CONF_IND_OFFSET_CONFSTATUS ) )
 {
 // configure resource control if CC enabled in (U)SIM
 // MT call is always controlled by NTSY
 if ( iCallControlEnabled )
 }
 case CALL_MODEM_RESOURCE_CONF_RESP:
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_RESP");
 OstTrace0( TRACE_NORMAL, DUP2_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_RESP" );
 if ( CALL_MODEM_RES_CONF_SET ==
 aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_RESOURCE_CONF_RESP_OFFSET_CONFOPERATION ) )
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_RESP Resource configured");
 OstTrace0( TRACE_NORMAL, DUP3_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_CONF_RESP Resource configured" );
 }
 break;
 }
 case CALL_MODEM_RESOURCE_RESP:
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_RESP Resource control sequence done");
 OstTrace0( TRACE_NORMAL, DUP4_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, CALL_MODEM_RESOURCE_RESP Resource control sequence done" );
 break;
 }
 default:
 {
 // none
 }
 case SS_RESOURCE_CONF_IND:
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, SS_RESOURCE_CONF_IND");
 OstTrace0( TRACE_NORMAL, DUP5_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, SS_RESOURCE_CONF_IND" );
 if ( SS_RESOURCE_CONF_READY  ==
 aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 SS_RESOURCE_CONF_IND_OFFSET_CONFSTATUS  ) )
 {
 // configure resource control if CC enabled in (U)SIM
 if ( iCallControlEnabled )
 {
 }
 break;
 }
 case SS_RESOURCE_CONF_RESP:
 {
 if ( SS_RESOURCE_CONF_SET ==
 aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 SS_RESOURCE_CONF_RESP_OFFSET_CONFOPERATION  ) )
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, SS_RESOURCE_CONF_RESP Resource configured");
 OstTrace0( TRACE_NORMAL, DUP6_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, SS_RESOURCE_CONF_RESP Resource configured" );
 }
 break;
 }
 case SS_STATUS_IND:
 {
 TUint8 status( aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 SS_STATUS_IND_OFFSET_SSSTATUSINDICATION  ) );
 if ( SS_STATUS_REQUEST_SERVICE_FAILED == status
 || SS_GSM_STATUS_REQUEST_USSD_FAILED )
 {
 }
 break;
 }
 case GPDS_RESOURCE_CONF_RESP:
 {
 if ( GPDS_RESOURCE_CONF_SET ==
 aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 GPDS_RESOURCE_CONF_RESP_OFFSET_CONFOPERATION  ) )
 {
 TFLOGSTRING("TSY: CSatCC::MessageReceived, GPDS_RESOURCE_CONF_RESP Resource configured");
 OstTrace0( TRACE_NORMAL, DUP9_CSATCC_MESSAGERECEIVED, "TSY: CSatCC::MessageReceived, GPDS_RESOURCE_CONF_RESP Resource configured" );
 ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
 CALL_MODEM_SB_RESOURCE,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset ) );
 if ( KErrNone == retValue
 && CALL_MODEM_RES_ID_MO_INIT & aIsiMessage.Get16bit( sbStartOffset +
 CALL_MODEM_SB_RESOURCE_OFFSET_RES  ) )
 {
 TCallControl callcontrol;
 // store traid's
 callcontrol.iTransId = aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_RESOURCE_IND_OFFSET_TRID );
 callcontrol.iRecourceId = aIsiMessage.Get8bit(
 ISI_HEADER_OFFSET_RESOURCEID);
 callcontrol.iCallId = aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_RESOURCE_IND_OFFSET_CALLID );
 retValue = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
 CALL_MODEM_SB_RESOURCE_SEQ_ID,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset );
 if( KErrNone == retValue )
 {
 callcontrol.iResourceSeqId = aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_RESOURCE_SEQ_ID_OFFSET_SEQUENCEID );
 }
 retValue = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
 CALL_MODEM_SB_MODE,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset );
 if( KErrNone == retValue )
 {
 callcontrol.iCallMode.Append( aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_MODE_OFFSET_MODE ) );
 callcontrol.iCallMode.Append( aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_MODE_OFFSET_MODEINFO ) );
 }
 retValue = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
 sbStartOffset );
 if( KErrNone == retValue )
 {
 TInt bearerLength( aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_BC_OFFSET_BCLENGTH ) );
 callcontrol.iBearerCapabilities.Copy( aIsiMessage.GetData(
 sbStartOffset + CALL_MODEM_SB_BC_OFFSET_BCDATA,
 bearerLength ) );
 }
 retValue = aIsiMessage.FindSubBlockOffsetById(
 {
 callcontrol.iAddressType = aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_DESTINATION_ADDRESS_OFFSET_ADDRTYPE );
 TUint8 addressLength( aIsiMessage.Get8bit( sbStartOffset +
 CALL_MODEM_SB_DESTINATION_ADDRESS_OFFSET_ADDRLEN ) );
 callcontrol.iString.Copy( aIsiMessage.GetData( sbStartOffset +
 CALL_MODEM_SB_DESTINATION_ADDRESS_OFFSET_ADDR,
 addressLength * 2 ) );
 }
+retValue = aIsiMessage.FindSubBlockOffsetById(
+ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,
+CALL_MODEM_SB_CHECK_INFO,
+EIsiSubBlockTypeId8Len8,
+sbStartOffset );
+if( KErrNone == retValue )
+{
+callcontrol.iCheckInfo = aIsiMessage.GetData( sbStartOffset,
+SIZE_CALL_MODEM_SB_CHECK_INFO );
+}
 if( CALL_MODEM_MODE_EMERGENCY == callcontrol.iCallMode[0] )
 {
 // Do not make SIM call control, allow emergency calls always
 TPtrC8 atkData;
 SendCallModemResourceReq(
 // Add mandatory data
 // Modem Call ID [M]: the unique call ID or CALL_ID_NONE.
 isiMessage.Append( aTcc.iCallId );
 // CALL_MODEM_SB_RESOURCE [M]: resource. Shall be same as in the corresponding indication.
 TIsiSubBlock resource(
 isiMessage,
 CALL_MODEM_SB_RESOURCE,
 EIsiSubBlockTypeId8Len8 );
 TSatUtility::AppendWord( CALL_MODEM_RES_ID_MO_INIT, isiMessage );
 resource.CompleteSubBlock();
 // CALL_MODEM_SB_RESOURCE_SEQ_ID [M]: Sequence ID. Shall be same as in the corresponding indication.
 TIsiSubBlock resourceSeqId(
 isiMessage,
 CALL_MODEM_SB_RESOURCE_SEQ_ID,
 EIsiSubBlockTypeId8Len8 );
 isiMessage.Append( aTcc.iResourceSeqId  );
 isiMessage.Append( KPadding );
 }
 case KCcResultAllowedWithModifications:
 {
 // First check if this has been modified to a new SS/USSD action
 CTlv ssServerString;
 if ( KErrNone == response.TlvByTagValue( &ssServerString,
 KTlvSsStringTag ) ||
 KErrNone == response.TlvByTagValue( &ssServerString,
 KTlvUssdStringTag ) )
 {
 isiMessage.Append( CALL_MODEM_RESOURCE_DENIED );
 status.CompleteSubBlock();
 if ( KRejected == internalCcResult || KChanged == internalCcResult )
 {
 // CALL_MODEM_SB_CAUSE sb is needed in rejected cases
 TIsiSubBlock cause(
 isiMessage,
 CALL_MODEM_SB_CAUSE,
 EIsiSubBlockTypeId8Len8 );
 isiMessage.Append( CALL_MODEM_CAUSE_TYPE_CLIENT  );
 isiMessage.Append( CALL_MODEM_CAUSE_NOT_ALLOWED );
 cause.CompleteSubBlock();
 sbcount++;
 }
 // CALL_MODEM_SB_MODE [M]: call mode.
 TIsiSubBlock mode(
 isiMessage,
 CALL_MODEM_SB_MODE,
 EIsiSubBlockTypeId8Len8 );
 // 2 byte buffer
 isiMessage.Append( aTcc.iCallMode );
 mode.CompleteSubBlock();
 // CALL_MODEM_SB_BC [M]: Bearer Capabilities for the call.
 TIsiSubBlock bearer(
 isiMessage,
 CALL_MODEM_SB_BC,
 EIsiSubBlockTypeId8Len8 );
 // Check if (U)SIM has provided new bearer caps
 isiMessage.Append( aTcc.iBearerCapabilities.Length() );
 isiMessage.Append( aTcc.iBearerCapabilities );
 }
 bearer.CompleteSubBlock();
 TIsiSubBlock address(
 isiMessage,
 CALL_MODEM_SB_DESTINATION_ADDRESS ,
 EIsiSubBlockTypeId8Len8 );
 // Check if request has been modified and therefore response includes
 // additional data
 {
 // CALL_MODEM_ADDRESS_TYPE, mask MSB off
 isiMessage.Append( addressTlv.GetValue()[ 0 ] ^KMSBMask );
 isiMessage.Append( KPadding );
 isiMessage.Append( KPadding );
 // Temp storage for address
 TBuf8<2 * KCallServerMaxAddressLenght> asciiAddress;
 TSatUtility::BCDToAscii( addressTlv.GetValue().Mid( 1 ),
 asciiAddress );
 //add the number string as unicode.
 TBuf16<KCallServerMaxAddressLenght> unicodeNumber;
 TSatUtility::ConvertSms7ToUnicode16( unicodeNumber, asciiAddress );
 TBuf8<2 * KCallServerMaxAddressLenght> temp;
 TIsiUtility::CopyToBigEndian( unicodeNumber, temp );
 // Address length = Number of Unicode characters in address
 isiMessage.Append( temp.Length()/2 );
 isiMessage.Append( temp );
 address.CompleteSubBlock();
 sbcount++;
 }
 CTlv subAddressTlv;
 ret = response.TlvByTagValue( &subAddressTlv, KTlvSubaddressTag );
 if ( KErrNone == ret )
 {
 TIsiSubBlock subAddress(
 isiMessage,
 CALL_MODEM_SB_DESTINATION_SUBADDRESS,
 EIsiSubBlockTypeId8Len8 );
 isiMessage.Append( subAddressTlv.GetLength() );
 isiMessage.Append( subAddressTlv.GetData( ETLV_SubAddress ) );
 isiMessage.Append( aTcc.iString );
 address.CompleteSubBlock();
 sbcount++;
 }
+// CALL_MODEM_SB_CHECK_INFO[O]: bitfield saying if some checks
+// should be ignored in Call Modem Server
+if ( aTcc.iCheckInfo.Length() )
+{
+isiMessage.Append( aTcc.iCheckInfo );
+sbcount++;
+}
 TBuf8<1> numOfSubblocks;
 numOfSubblocks.Append( sbcount);
 isiMessage.Insert( 1, numOfSubblocks );
+// before sending the call control result to call server,
+// inform NTSY about call control CALL_ID and call control result
+CMmDataPackage dataPackage;
+TUint8 callId( aTcc.iCallId );
+dataPackage.PackData( &callId, &ccresult );
+iSatMessaging->GetMessageRouter()->ExtFuncL(
+ESatNotifyCallControlRequest, &dataPackage );
 // send request
 iSatMessHandler->CallModemResourceReq( aTcc.iTransId, isiMessage );
 if ( KCcEmptyResponseLenght < aApduData.Length() )
 {
 OstTrace0( TRACE_NORMAL, CSATCC_SSRESOURCECONTROLIND, "CSatCC::SsResourceControlInd" );
 TCallControl callcontrol;
 TInt stringLength;
 // store traid's
 callcontrol.iTransId = aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 SS_RESOURCE_CONTROL_IND_OFFSET_TRANSID );
 callcontrol.iRecourceId = aIsiMessage.Get8bit(
 ISI_HEADER_OFFSET_RESOURCEID);
 TUint sbStartOffset( 0 );
 TInt retValue( aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_SS_RESOURCE_CONTROL_IND,
 SS_SB_RESOURCE_SEQ_ID,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset ) );
 if( KErrNone == retValue )
 {
 callcontrol.iResourceSeqId = aIsiMessage.Get8bit( sbStartOffset +
 SS_SB_RESOURCE_SEQ_ID_OFFSET_SEQUENCEID );
 }
 retValue = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_SS_RESOURCE_CONTROL_IND,
 SS_SB_SS_CONTROL,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset );
 if( KErrNone == retValue )
 {
 stringLength = aIsiMessage.Get8bit( sbStartOffset +
 SS_SB_SS_CONTROL_OFFSET_SSSTRINGLENGTH );
 callcontrol.iString.Copy( aIsiMessage.GetData(
 sbStartOffset + SS_SB_SS_CONTROL_OFFSET_SSSTRING,
 stringLength) );
 }
 retValue = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_SS_RESOURCE_CONTROL_IND,
 SS_SB_USSD_CONTROL,
 EIsiSubBlockTypeId8Len8,
 sbStartOffset );
 if( KErrNone == retValue )
 {
 callcontrol.iUssdCodingInfo = aIsiMessage.Get8bit( sbStartOffset +
 SS_SB_USSD_CONTROL_OFFSET_CODINGINFO );
 stringLength = aIsiMessage.Get8bit( sbStartOffset +
 SS_SB_USSD_CONTROL_OFFSET_USSDSTRINGLENGTH  );
 callcontrol.iUssdString.Copy( aIsiMessage.GetData(
 sbStartOffset + SS_SB_USSD_CONTROL_OFFSET_USSDSTRING,
 stringLength ) );
 }
 // store struct
 iCallControlArray->Append( callcontrol );
 // -----------------------------------------------------------------------------
 // CSatCC::SendSsResourceControlReq
 // Creates resource control response for modem SS server
 // -----------------------------------------------------------------------------
 //
 void CSatCC::SendSsResourceControlReq(
 const TCallControl& aTcc,
 const TUint8 aResult,
 TPtrC8 aApduData )
 {
 TFLOGSTRING("TSY: CSatCC::SendSsResourceControlReq");
 // SS_RESOURCE_CONTROL_REQ has 3 mandatory sb's
 TUint8 sbcount( 3 );
 // Add mandatory data
 isiMessage.Append( KPadding );
 // SS_SB_RESOURCE [M]: resource. Shall be same as in the corresponding indication.
 TIsiSubBlock resource(
 isiMessage,
 SS_SB_RESOURCE ,
 EIsiSubBlockTypeId8Len8 );
 TSatUtility::AppendWord( SS_RES_ID_MO_SS_OPERATION, isiMessage );
 resource.CompleteSubBlock();
 // SS_SB_RESOURCE_SEQ_ID [M]: [M]: Sequence ID. Shall be same as in the corresponding indication.
 TIsiSubBlock resourceSeqId(
 isiMessage,
 SS_SB_RESOURCE_SEQ_ID,
 EIsiSubBlockTypeId8Len8 );
 isiMessage.Append( aTcc.iResourceSeqId  );
 isiMessage.Append( KPadding );
 case KCcResultAllowedWithModifications:
 {
 // First check if this has been modified to a new CALL
 CTlv address;
-if ( KErrNone == response.TlvByTagValue(
+if ( KErrNone == response.TlvByTagValue( &address,
-&address, KTlvAddressTag ) )
+KTlvAddressTag ) )
 {
 // Original action has been modified to call
 isiMessage.Append( SS_RESOURCE_DENIED );
 isiMessage.Append( KPadding );
 internalCcResult = KChanged;
 isiMessage.Append( SS_RESOURCE_DENIED );
 isiMessage.Append( KPadding );
 internalCcResult = KChanged;
 changedSsServerAction = ETrue;
 }
-else
+else if ( KErrNone == response.TlvByTagValue( &ssServerString,
+KTlvSsStringTag ) )
 {
 // original SS string has been modified to new SS string
 isiMessage.Append( SS_RESOURCE_ALLOWED );
 isiMessage.Append( KPadding );
 internalCcResult = KModified;
 isiMessage.Append( SS_RESOURCE_DENIED );
 isiMessage.Append( KPadding );
 internalCcResult = KChanged;
 changedSsServerAction = ETrue;
 }
-else
+else if ( KErrNone == response.TlvByTagValue( &ssServerString,
+KTlvUssdStringTag ) )
 {
 // USSD string has been modified to new USSD string
 isiMessage.Append( SS_RESOURCE_ALLOWED );
 isiMessage.Append( KPadding );
 internalCcResult = KModified;
 {
 TIsiSubBlock ssControl(
 isiMessage,
 SS_SB_SS_CONTROL,
 EIsiSubBlockTypeId8Len8 );
 TUint8 tonNpi( ssStringTlv.GetValue()[0] );
 TPtrC8 ssString( ssStringTlv.GetValue().Mid(1) );
 TBuf8<255> ss;
 TSatUtility::BCDToAscii( ssString, ss );
 ussdControl.CompleteSubBlock();
 sbcount++;
 }
 }
 }
 TBuf8<1> numOfSubblocks;
 numOfSubblocks.Append( sbcount);
 isiMessage.Insert( 1, numOfSubblocks );
 // send request
 iSatMessHandler->SsResourceControlReq( aTcc.iTransId, isiMessage );
 TCallControl callcontrol;
 TInt paramsLength;
 TBuf8<KPdpContextActivationParamsMaxSize> paramsBuffer;
 // store traid's
 callcontrol.iTransId = aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 GPDS_RESOURCE_CONTROL_REQ_OFFSET_UTID );
 callcontrol.iRecourceId = aIsiMessage.Get8bit(
 ISI_HEADER_OFFSET_RESOURCEID);
 callcontrol.iResourceSeqId = aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 GPDS_RESOURCE_CONTROL_IND_OFFSET_SEQUENCEID );
 if( KErrNone == retValue )
 {
 paramsLength = aIsiMessage.Get16bit( sbStartOffset +
 GPDS_ACTIVATE_PDP_CONTEXT_REQUEST_OFFSET_DATALENGTH );
 paramsBuffer.Copy( aIsiMessage.GetData(
 sbStartOffset + GPDS_ACTIVATE_PDP_CONTEXT_REQUEST_OFFSET_DATA,
 paramsLength) );
 }
 // store struct
 // -----------------------------------------------------------------------------
 // CSatCC::SendGpdsResourceControlReq
 // Creates resource control response for modem GPDS server
 // -----------------------------------------------------------------------------
 //
 void CSatCC::SendGpdsResourceControlReq(
 const TCallControl& aTcc,
 const TUint8 aResult,
 TPtrC8 aAtkData )
 {
 TFLOGSTRING("TSY: CSatCC::SendGpdsResourceControlReq");
 OstTrace0( TRACE_NORMAL, CSATCC_SENDGPDSRESOURCECONTROLREQ, "CSatCC::SendGpdsResourceControlReq" );
 }
 case KCcResultAllowedWithModifications:
 {
 // response is modified in GPDS server terminology only if
 // new PDP params are provided
 if ( KCcEmptyResponseLenght < aAtkData.Length()
 && KErrNone == response.TlvByTagValue( &paramsTlv,
 KTlvPdpContextActivationParametersTag ) )
 {
 isiMessage.Append( GPDS_MODIFIED );
 isiMessage.AppendFill( KPadding, 3 );
 {
 // GPDS_ACTIVATE_PDP_CONTEXT_REQUEST is shall be present if and only if
 // Resource is GPDS_CC_FOR_GPRS and Result is GPDS_MODIFIED
 if ( RSat::EAllowedWithModifications == internalCcResult )
 {
 TIsiSubBlock contextParams(
 isiMessage,
 GPDS_ACTIVATE_PDP_CONTEXT_REQUEST,
 EIsiSubBlockTypeId8Len16 );
 TInt paramsLength( paramsTlv.GetLength() );
 // Set data length

changeset 5	8ccc39f9d787
parent 0	63b37f68c1ce
child 7	fa67e03b87df