/*

* 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 "satcc.h"              // sat call control class

#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"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "satccTraces.h"

#endif

// CONSTANTS

// Zero character code

const TUint8 KZeroCharacterCode                 = 0x30;

// Maximum length for PDP Context Activation Parameters, see 3GPP TS 31.111

const TUint8 KPdpContextActivationParamsMaxSize = 124;

// From 3GPP TS 31.111, 7.3.1.6 Structure of ENVELOPE (CALL CONTROL)

const TUint8 KCcResultAllowedNoModification     = 0x00;

const TUint8 KCcResultNotAllowed                = 0x01;

const TUint8 KCcResultAllowedWithModifications  = 0x02;

// Maximum data length without additional TLVs in envelope response

const TUint8 KCcEmptyResponseLenght     = 0x02;

// Buffer seze used for all CC responses

const TInt KMaximumCcBufferSize =

    4 +     //CALL_MODEM_SB_RESOURCE

    4 +     //CALL_MODEM_SB_RESOURCE_SEQ_ID

    4 +     //CALL_MODEM_SB_RESOURCE_STATUS

    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;

const TUint8 KSw1Sw2Unknown = 0;

const TUint8 KValidTonNpi   = 0x3F;

// ==================== MEMBER FUNCTIONS ====================================

// -----------------------------------------------------------------------------

// CSatCC::CSatCC

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CSatCC::CSatCC

        (

        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler

        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class

        )

        :

        iSatMessHandler( aSatMessHandler ),

        iSatMessaging( aSatMessaging ),

        iTonNpiPresent( EFalse ),

        iEnvelopeResponseData( NULL )

    {

    }

// -----------------------------------------------------------------------------

// CSatCC::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CSatCC::ConstructL()

    {

    TFLOGSTRING("TSY: CSatCC::ConstructL");

    // Create array for CC request information storing

    iCallControlArray = new( ELeave ) RArray<TCallControl>( 1 );

    iUssdTlvSupported = EFalse;

    }

// -----------------------------------------------------------------------------

// CSatCC::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CSatCC* CSatCC::NewL

        (

        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler

        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class

        )

    {

    TFLOGSTRING("TSY: CSatCC::NewL");

    CSatCC* self = new( ELeave ) CSatCC( aSatMessHandler, aSatMessaging );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CSatCC::~CSatCC

// C++ destructor

// -----------------------------------------------------------------------------

//

CSatCC::~CSatCC()

    {

    TFLOGSTRING("TSY: CSatCC::~CSatCC");

    if( iCallControlArray )

        {

        iCallControlArray->Close();

        delete iCallControlArray;

        }

    if ( iEnvelopeResponseData )

        {

        delete iEnvelopeResponseData;

        }

    }

// -----------------------------------------------------------------------------

// CSatCC::GetArrayIndexById

// Helper method for searching desired information from array

// used for locating stored call control event information

// -----------------------------------------------------------------------------

//

TInt CSatCC::GetArrayIndexById

        (

        const TInt &aTid

        )

    {

    TFLOGSTRING("TSY: CSatCC::GetArrayIndexById");

    TInt ret ( KErrNotFound );

    TInt arraySize ( iCallControlArray->Count() );

    // Only there's Cc transaction ongoing

    if ( arraySize )

        {

        for ( TInt i = 0 ; ret == KErrNotFound && i < arraySize ; i++ )

            {

            if ( ( *iCallControlArray )[i].iTransId == aTid )

                {

                ret = i;

                }

            }

        if ( KErrNotFound == ret)

            {

            TFLOGSTRING3("TSY: CSatCC::GetArrayIndexById, Error:ID 0x%x not found. Array size: %d", aTid, arraySize );

            }

        }

    else

        {

        //None. This is not our message.

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// CSatCC::AddLocationInformationToTlv

// Adds location informating to given TTlv.

// -----------------------------------------------------------------------------

//

void CSatCC::AddLocationInformationToTlv

        (

        TTlv& aTlv //Tlv to be sent

        )

    {

    TFLOGSTRING("TSY: CSatCC::AddLocationInformationToTlv");

    const CSatMessHandler::TLocationInfo& locInfo

        = iSatMessHandler->LocationInfo();

    aTlv.AddTag( KTlvLocationInformationTag );

    // append Mobile Country  & Network Codes, 3 bytes

    aTlv.AddData( locInfo.iOperatorCode );

    // append LAC code

    aTlv.AddData( locInfo.iLac );

    // append CellId

    aTlv.AddData( locInfo.iCellId );

    }

// -----------------------------------------------------------------------------

// CSatCC::SendSSEnvelope

// Sends call control SS envelope

// -----------------------------------------------------------------------------

//

TInt CSatCC::SendSSEnvelope

        (

        const TCallControl& aCcstruct //Structure containing call event info

        )

    {

    TFLOGSTRING("TSY: CSatCC::SendSSEnvelope");

    // create envelope

    TTlv envelope;

    envelope.Begin  ( KBerTlvCallControlTag );

    // device identities

    envelope.AddTag ( KTlvDeviceIdentityTag );

    envelope.AddByte( KMe );

    envelope.AddByte( KSim );

    // SS string

    envelope.AddTag( KTlvSsStringTag );

    //There is no TON and NPI in SS cc request. Information is part of the

    //number string: Spec ETSI TS 122 030 v5.0.0 says that if number starts

    //with +, TON is international and if it starts without it, it's unknown.

    //Default NPI is used if all digits are in the range 0-9.

    //NPI shall be unknown if other number information is included.

    //In any case if the user has selected some particular

    //NPI, that will be used.

    TInt i( 0 );

    TUint8 tonNpi( KTonNpiUnknown );

    // If SS is entered by user, there's no SEND SS from where to resolve TonNpi

    // Then TonNpi is resolved from SS string

    // TonNpi   = Unknown if '+'-sign is not present

    //          = International if '+'-sign is found

    //          = No TonNpi if phone number is not present or SS-string contains

    //            only SS code

    if ( !iTonNpiPresent )

        {

        // 3GPP TS 22 030 V7.0.0 (2004-03) says:

        // "The procedure always starts with *, #, **, ## or *#

        // and is finished by #. Each part within the procedure

        // is separated by *."

        // skip start characters

        while ( ( i < aCcstruct.iString.Length() ) &&

                 ( ( '*' == aCcstruct.iString[i] ) ||

                   ( '#' == aCcstruct.iString[i] ) ) )

            {

            i++;

            }

        TInt ssCode( 0 );

        // seek for separation character and store service code

        while ( ( i < aCcstruct.iString.Length() )

                && ( '*' != aCcstruct.iString[i] )

                && ( '#' != aCcstruct.iString[i] ) )

            {

            ssCode *= 10;

            ssCode += ( aCcstruct.iString[i] - KZeroCharacterCode );

            i++;

            }

        // With these SS codes dialling number may be included. It's located

        // after first separation mark '*', but it can be empty.

        // See 3GPP TS 22.030 7.0.0, 6.5.2 and Annex B.

        // With checking the service code ton/npi resolving is made

        // unambiguous.

        // Structure of SS string: *service code*SIA*SIB*SIC#

        // Content of SIB and SIC have no impact to ton/npi

        if( SS_GSM_ALL_FORWARDINGS == ssCode

            || SS_GSM_ALL_COND_FORWARDINGS == ssCode

            || SS_GSM_FORW_UNCONDITIONAL == ssCode

            || SS_GSM_FORW_BUSY == ssCode

            || SS_GSM_FORW_NO_REPLY == ssCode

            || SS_GSM_FORW_NO_REACH == ssCode)

            {

            // Set tonNpi international, if separation character (*) and (+)

            // sign is found

            if ( ( ( i + 1 ) < aCcstruct.iString.Length() )

                && ( ( '*' == aCcstruct.iString[i] )

                && ( '+' == aCcstruct.iString[i + 1] ) ) )

                {

                tonNpi = KTonNpiInternational;

                }

            // Procedure is finished by #

            // If * is not found -> no number found

            else if ( ( i < aCcstruct.iString.Length() )

                    && ('#' == aCcstruct.iString[i] ) )

                {

                tonNpi = KNoTonNpi;

                }

            // Additional check for (**) "double star" case

            else if ( ( ( i + 1 )  < aCcstruct.iString.Length() )

                    && ( '*' == aCcstruct.iString[i] )

                    && ( '*' == aCcstruct.iString[i + 1] ) )

                {

                // ** means there is an additional SIB field included,

                // but SIA (number) is empty

                // PhoneNumber is not present

                tonNpi = KNoTonNpi;

                }

            // All other compinations shall result the "unknown" ton/npi

            else

                {

                // Number is found but its tonnpi is unknown

                tonNpi = KTonNpiUnknown;

                }

            }

        else

            {

            //With all other SS codes TON/NPI is set to 0xff

            tonNpi = KNoTonNpi;

            }

        }

    else

        {

        // TonNpi is resolved from SEND SS proactive command

        tonNpi = iTonNpiForSS;

        }

    iTonNpiPresent = EFalse;

    envelope.AddByte( tonNpi );

    TBuf8<255> ss;

    TSatUtility::AsciiToBCD( aCcstruct.iString, ss );

    envelope.AddData( ss );

    // location information

    AddLocationInformationToTlv( envelope );

    // send it away...

    return iSatMessHandler->UiccCatReqEnvelope(

        aCcstruct.iTransId,

        envelope.End());

    }

// -----------------------------------------------------------------------------

// Sends call control USSD envelope

// -----------------------------------------------------------------------------

//

        (

        const TCallControl& aCcstruct //Structure containing call event info

        )

    {

    TInt ret( KErrNone );

    // create envelope

    TTlv envelope;

    envelope.Begin( KBerTlvCallControlTag );

    // device identities

    envelope.AddTag( KTlvDeviceIdentityTag );

    envelope.AddByte( KMe );

    envelope.AddByte( KSim );

    // USSD string tlv supported

    if ( iUssdTlvSupported )

        {

        envelope.AddTag( KTlvUssdStringTag );

        envelope.AddByte( aCcstruct.iUssdCodingInfo );

        envelope.AddData( aCcstruct.iUssdString );

        AddLocationInformationToTlv( envelope );

        ret = iSatMessHandler->UiccCatReqEnvelope(

            aCcstruct.iTransId,

            envelope.End() );

        }

    else

        {

        // UssdTlv is not supported by the SIM, with Call control

        // Checks whether the USSD string can be coded in the SS obj. SS obj.

        // can only contain "*", "#", and the numbers 0-9.

        if ( IsOnlyDigitsInUssd( aCcstruct.iUssdString ) )

            {

            envelope.AddTag( KTlvSsStringTag );

            // If the Dialling Number/SSC String does not contain a dialling

            // number e.g. a control string deactivating a service, the

            // TON/NPI byte shall be set to 'FF' by the ME (see note

            // 3GPP TS 11.11). in this case TON & NPI must be set to 0xFF

            envelope.AddByte( 0xFF );

            TBuf8<255> ss;

            TSatUtility::AsciiToBCD( aCcstruct.iUssdString, ss );

            envelope.AddData( ss );

            AddLocationInformationToTlv( envelope );

            ret = iSatMessHandler->UiccCatReqEnvelope(

                aCcstruct.iTransId,

                envelope.End());

            }

        else

            {

            // 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;

                atkData );

            TInt index( GetArrayIndexById( aCcstruct.iTransId ) );

            if ( index != KErrNotFound )

                {

                iCallControlArray->Remove( index );

                iCallControlArray->Compress();

                }

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// CSatCC::SendCallEnvelope

// Sends call control call envelope

// -----------------------------------------------------------------------------

//

TInt CSatCC::SendCallEnvelope

        (

        const TIsiReceiveC& aIsiMessage,

        const TCallControl& aCallControl //Structure containing call event info

        )

    {

    // create envelope

    TTlv envelope;

    envelope.Begin( KBerTlvCallControlTag );

    // device identities

    envelope.AddTag( KTlvDeviceIdentityTag );

    envelope.AddByte( KMe );

    envelope.AddByte( KSim );

    // address is mandatory

    TInt addressLength( 0 );

    TUint sbStartOffset( 0 );

    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

        TBuf8<123> address;

        TSatUtility::AsciiToBCD( aCallControl.iString, address );

        envelope.AddData( address );

        }

    // In Nokia context BC is mandatory

    envelope.AddTag( KTlvCapabilityConfigurationParametersTag );

    // Length of actual BC information element

    envelope.AddByte( aCallControl.iBearerCapabilities.Length() );

    envelope.AddData( aCallControl.iBearerCapabilities );

    // If subaddress present

    retValue = aIsiMessage.FindSubBlockOffsetById(

          ISI_HEADER_SIZE + SIZE_CALL_MODEM_RESOURCE_IND ,

          CALL_MODEM_SB_DESTINATION_SUBADDRESS,

          EIsiSubBlockTypeId8Len8,

          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..

    return iSatMessHandler->UiccCatReqEnvelope(

        aCallControl.iTransId,

        envelope.End() );

    }

// -----------------------------------------------------------------------------

// CSatCC::SendPdpContextActivationEnvelope

// Sends Call Control PDP context activation envelope

// -----------------------------------------------------------------------------

//

TInt CSatCC::SendPdpContextActivationEnvelope

        (

        const TUint8 aPdpCcEnvelopeTid,

        const TDesC8& aPdpContextActivationParams

        )

    {

    TFLOGSTRING( "TSY: CSatCC::SendPdpContextActivationEnvelope" );