/*

* Copyright (c) 2007-2010 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 "satmosmsctrl.h"       // sat mo sms 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 <pn_const.h>           // server id constants

#include <tisi.h>               // isi message

#include <uiccisi.h>            // UICC server

#include <smsisi.h>             // sms server

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "satmosmsctrlTraces.h"

#endif

// CONSTANTS

const TUint8 KReservedTonNpi1           = 0x7F;

const TUint8 KReservedTonNpi2           = 0xF7;

const TUint8 KMaxLengthAddr1Addr2       = 249;

const TUint8 KMaxLengthOfAtkSwDataNtf   = 255;

const TUint8 KMaxLengthOfResourceReq    = 255;

const TUint8 KSmControlAllowed          = 0;

const TUint8 KSmControlNotAllowed       = 1;

const TUint8 KSmControlAllowedWithModif = 2;

const TUint8 KSmsSubmitAddrDataIndex    = 3;

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

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

// CSatMoSmsCtrl::CSatMoSmsCtrl

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

// might leave.

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

//

CSatMoSmsCtrl::CSatMoSmsCtrl

        (

        CSatMessHandler*    aSatMessHandler,

        CTsySatMessaging*   aSatMessaging

        )

        :

        iSatMessHandler( aSatMessHandler ),

        iSatMessaging( aSatMessaging ),

        iWaitingForEnvelopeResp( EFalse ),

        iIsMoSmsCtrlActivated( EFalse ),

        iMoSmsCtrlEnvelopeTransactionId( KZero ),

        iMoSmsCtrlReqTransactionId( KZero ),

        iSenderObject( KZero )

    {

    }

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

// CSatMoSmsCtrl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSatMoSmsCtrl::ConstructL()

    {

    // Check MO SMS control is supported by ME's Product Profile

    iSatMessHandler->InfoPpReadReq( INFO_PP_ATK_MO_SM_CONTROL );

#else

    // Check if MO-SMS control should be activated in SMS server

    // This is done by sending a request SimReadTableReq to Sim server, with

    // service type KSimStMoSmsSimControlAvail

    iSatMessHandler->SimReadTableReq( SIM_ST_MO_SMS_SIM_CONTROL_AVAIL );

    }

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

// CSatMoSmsCtrl::NewL

// Two-phased constructor.

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

//

CSatMoSmsCtrl* CSatMoSmsCtrl::NewL

        (

        CSatMessHandler*    aSatMessHandler,

        CTsySatMessaging*   aSatMessaging

        )

    {

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

    CSatMoSmsCtrl* self =

        new( ELeave ) CSatMoSmsCtrl( aSatMessHandler, aSatMessaging );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSatMoSmsCtrl::~CSatMoSmsCtrl

// Destructor

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

//

CSatMoSmsCtrl::~CSatMoSmsCtrl()

    {

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

    }

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

// CSatMoSmsCtrl::IsActivated

// Returns ETrue if MO-SMS Control is activated

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

//

TBool CSatMoSmsCtrl::IsActivated()

    {

    TFLOGSTRING("TSY: CSatMoSmsCtrl::IsActivated");

    return iIsMoSmsCtrlActivated;

    }

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

// CSatMoSmsCtrl::Activate

// Set iIsMoSmsCtrlActivated to ETrue if MO-SMS Control has to be activated

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

//

void CSatMoSmsCtrl::Activate()

    {

    TFLOGSTRING("TSY: CSatMoSmsCtrl::Activate");

    iIsMoSmsCtrlActivated = ETrue;

    }

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

// CSatMoSmsCtrl::Deactivate

// Set iIsMoSmsCtrlActivated to EFalse if MO-SMS Control has to be deactivated

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

//

void CSatMoSmsCtrl::Deactivate()

    {

    TFLOGSTRING("TSY: CSatMoSmsCtrl::Deactivate");

    iIsMoSmsCtrlActivated = EFalse;

    }

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

// CSatMoSmsCtrl::UiccCatRespEnvelopeReceived

// Handler function of incoming MO-SMS Control related data notification messages

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

//

TInt CSatMoSmsCtrl::UiccCatRespEnvelopeReceived

        (

        const TIsiReceiveC& aIsiMessage //Received data notification

        )

    {

    TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived");

    TBuf8<KMaxLengthOfAtkSwDataNtf> addr1;

    TBuf8<KMaxLengthOfAtkSwDataNtf> addr2;

    iWaitingForEnvelopeResp = EFalse;

    TUint8 status( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + UICC_CAT_RESP_OFFSET_STATUS ) );

    TBool simRespDataConsistent = ETrue;

    TUint8 resourceStatus = 0;

    TUint8 sw1( 0 );

    TUint8 sw2( 0 );

    TInt8 atkResult( 0 );

    TUint8 numSb( 3 ); // Mandatory no of subblocks

    TBuf8<SIZE_SMS_RESOURCE_REQ+SIZE_SMS_SB_RESOURCE+SIZE_SMS_SB_RESOURCE_SEQ_ID+

        SIZE_SMS_SB_ADDRESS+SMS_ADDRESS_MAX_LEN+SIZE_SMS_SB_TPDU_PACKING+

        SMS_TPDU_MAX_LEN+SIZE_SMS_SB_CAUSE> dataResp;

    TIsiSend resourceReq( dataResp );

    dataResp.AppendFill( KPadding, 1 ); // filler byte

    dataResp.Append( numSb ); // no of Subblocks

    if ( UICC_STATUS_OK == status )

        {

        TUint uiccSbApduOffset( 0 );

        if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(

            ISI_HEADER_SIZE + SIZE_UICC_CAT_RESP,

            UICC_SB_APDU,

            EIsiSubBlockTypeId16Len16,

            uiccSbApduOffset ) )

            {

            TPtrC8 apduData;

            TUint16 apduLength( aIsiMessage.Get16bit(

                uiccSbApduOffset + UICC_SB_APDU_OFFSET_APDULENGTH ) );

            apduData.Set( aIsiMessage.GetData(

                uiccSbApduOffset + UICC_SB_APDU_OFFSET_APDU,

                apduLength ) );

            // Status bytes are two last bytes in APDU

            sw1 = apduData[apduLength - 2];

            sw2 = apduData[apduLength - 1];

            // Get Call Control General Result

            atkResult = TSatUtility::Sw1Sw2Check( sw1, sw2 );

            if ( KError != atkResult ) // If ATK result is OK

                {

                TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, Ok");

                RSat::TAlphaId alphaId;

                alphaId.iAlphaId.Zero();

                TBool isAlphaIdEmpty( EFalse );

                if ( KMaxLengthOfAtkSwDataNtf < apduLength ) // If data length greater than 255

                    {

                    TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, the length of Sim resp data is > 255" );

                    // Data is not consistent, so not allowed condition

                    if( KSmControlNotAllowed == apduData[0] )

                        {

                        resourceStatus = SMS_RESOURCE_DENIED;

                        }

                    else

                        {

                        resourceStatus  = SMS_RESOURCE_ALLOWED;

                        }

                    FormSmsResourceReqSb( resourceStatus, dataResp, addr1, addr2 );

                    // Send resp to SMS server

                    // Return to the calling function right now, even if it's not

                    // a good thing to have several returns in the same method.

                    // To avoid it, more if statements would be needed and

                    // this doesn't make it any better.

                    return ( iSatMessHandler->SendSmsResourceReq(

                        iMoSmsCtrlReqTransactionId,

                        dataResp,

                        iSenderObject ) );

                    }

                else if ( apduLength ) // If data length in non zero and less than 255

                    {

                    TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, atkData.Length()!=0 ");

                    // Note: The alpha id can be provided by the SIM even if the addresses

                    // have not been modified.

                    ParseAtkSwDataNtf( apduData, addr1, addr2, alphaId, isAlphaIdEmpty );

                    if ( KSmControlAllowedWithModif == apduData[0] )

                        {

                        simRespDataConsistent = VerifySimRespData( addr1, addr2 );

                        }

                    if ( simRespDataConsistent )

                        {

                        if( KSmControlNotAllowed == apduData[0] )

                            {

                            resourceStatus = SMS_RESOURCE_DENIED;

                            }

                        else

                            {

                            resourceStatus  = SMS_RESOURCE_ALLOWED;

                            }

                        FormSmsResourceReqSb( resourceStatus, dataResp, addr1, addr2 );

                        TFLOGSTRING2("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, apduData[0]: %d",apduData[0] );

                       }

                    else

                       {

                       TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, Sim response data not consistent" );

                       if( KSmControlNotAllowed == apduData[0] )

                           {

                           resourceStatus = SMS_RESOURCE_DENIED;

                           }

                       else

                           {

                           resourceStatus  = SMS_RESOURCE_ALLOWED;

                           }

                        FormSmsResourceReqSb( resourceStatus, dataResp, addr1, addr2 );

                        // Send resp to Sms server

                        // Return to the calling function right now, even if it's not

                        // a good thing to have several returns in the same method.

                        // To avoid it, more if statements would be needed and

                        // this doesn't make it any better.

                        return ( iSatMessHandler->SendSmsResourceReq(

                            iMoSmsCtrlReqTransactionId,

                            dataResp,

                            iSenderObject ) );

                        }

                    } // end of if statement for data length nonzero and less than 255

                else  // block for data length zero

                    {

                    TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, atkData.Length()=0 ");

                    TUint8 resourceStatus( SMS_RESOURCE_ALLOWED );

                    FormSmsResourceReqSb( resourceStatus, dataResp, addr1, addr2 );

                    }// end of block with data length zero

                // If AlphaID is present, the client SatServer

                // must be notified in order to inform it that the ETel

                // API MO-SMS Control structure TMoSmControlV1 has been modified.

                if ( alphaId.iAlphaId.Length() || isAlphaIdEmpty )

                    {

                    // Inform client

                    // Control result must be mapped to ETel API values.

                    TUint8 controlResult;

                    switch ( apduData[0] )

                        {

                        case KSmControlAllowed:

                            {

                            controlResult = RSat::EAllowedNoModification;

                            break;

                            }

                        case KSmControlAllowedWithModif:

                            {

                            controlResult = RSat::EAllowedWithModifications;

                            break;

                            }

                        case KSmControlNotAllowed:

                            {

                            controlResult = RSat::ENotAllowed;

                            break;

                            }

                        default:

                            {

                            controlResult = RSat::EControlResultNotSet;

                            break;

                            }

                        }

                    iSatMessaging->NotifyClientAboutMoSmControlEvent(

                    alphaId.iAlphaId, (RSat::TControlResult) controlResult );

                    }

                }

            }

        else // else for UICC status not ok

            {

            TFLOGSTRING("TSY:CSatMoSmsCtrl::UiccCatRespEnvelopeReceived, KAtkError = atkResult ");

            TUint8 resourceStatus = SMS_RESOURCE_DENIED;

            FormSmsResourceReqSb( resourceStatus, dataResp, addr1, addr2 );

            }

        } // end if if UICC status is ok

    // Send resp to Sms server

    return ( iSatMessHandler->SendSmsResourceReq(

        iMoSmsCtrlReqTransactionId,

        dataResp,

        iSenderObject ) );

    }

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

// CSatMoSmsCtrl::SmsResourceIndReceivedL

// Request received from SMS server with the SMS parameters

// of the SMS to be sent by the Mobile Equipment.

// The response will tell whether the SMS can be sent

// to network or not.

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

//

void CSatMoSmsCtrl::SmsResourceIndReceivedL

        (

        const TIsiReceiveC& aIsiMessage //Received data notification

        )

    {

    TFLOGSTRING("TSY:CSatMoSmsCtrl::SmsResourceIndReceivedL");

    TUint sbOffset;

    // Save the transaction id, which is going to

    // be re-used in the resp.

    iMoSmsCtrlReqTransactionId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );

    // Save the sender object id, in order to re-use it

    // in the response to this request

    iSenderObject = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_SENDEROBJECT );

    // Save Sequence id to send it in request message

    if ( KErrNotFound != aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE+SIZE_SMS_RESOURCE_IND,

        SMS_SB_RESOURCE_SEQ_ID,

        EIsiSubBlockTypeId16Len16,

        sbOffset ) )

        {

        iSequenceId = aIsiMessage.Get8bit(

            sbOffset + SMS_SB_RESOURCE_SEQ_ID_OFFSET_SEQUENCEID );

        }

    // save resource id to send it in request mesage

    if ( KErrNotFound != aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE+SIZE_SMS_RESOURCE_IND,

        SMS_SB_RESOURCE,

        EIsiSubBlockTypeId16Len16,

        sbOffset ) )

        {

        iResourceId = aIsiMessage.Get16bit(

            sbOffset + SMS_SB_RESOURCE_OFFSET_RESOURCES );

        }

    // Save Service Centre Address Subblock to send it in request message if server has

    //denied to access

    if ( KErrNotFound != aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE+SIZE_SMS_RESOURCE_IND,

        SMS_SB_ADDRESS,

        EIsiSubBlockTypeId16Len16,

        sbOffset ) )

        {

        TUint8 addressLength = aIsiMessage.Get8bit(

            sbOffset + SMS_SB_ADDRESS_OFFSET_ADDRESSDATALENGTH );

        // According to sms_isi specification

        __ASSERT_ALWAYS(

            2 <= addressLength && SMS_ADDRESS_MAX_LEN >= addressLength,

            User::Leave( KErrCorrupt ) );

        iAddressSubblock = aIsiMessage.GetData(

            sbOffset + SMS_SB_ADDRESS_OFFSET_ADDRESSDATA,

            addressLength );

        }

    else

        {

        iAddressSubblock.Zero();

        }

    // Save TPDU to send it in request message if server has

    // Denied the access for that address

     if ( KErrNotFound != aIsiMessage.FindSubBlockOffsetById(

         ISI_HEADER_SIZE+SIZE_SMS_RESOURCE_IND,

         SMS_SB_TPDU,

         EIsiSubBlockTypeId16Len16,

         sbOffset ) )

        {

        TUint8 tpduLength =

            aIsiMessage.Get8bit( sbOffset + SMS_SB_TPDU_OFFSET_DATALENGTH );

        iUserDataSubblock = aIsiMessage.GetData(

            sbOffset + SMS_SB_TPDU_OFFSET_DATABYTES,

            tpduLength );

         }

     else

         {

         iUserDataSubblock.Zero();

         }

        if( iIsMoSmsCtrlActivated )    // Check is MO SMS is activated or not

            {

            iMoSmsCtrlEnvelopeTransactionId = iSatMessaging->GetTransactionId();

            }

        else        // If MO SMS is not activated

            {

            }

        }

    }

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

// CSatMoSmsCtrl::SendMoSmsCtrlEnvelope

// Send an envelope to SIM server in order to check wheter the SMS

// can be sent or not. The response will be used to send a response

// to SMS server

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

//

void CSatMoSmsCtrl::SendMoSmsCtrlEnvelope

        (

        TUint8 aTraId,

        const TDesC8& aAddressData1,

        const TDesC8& aAddressData2

        )

    {

    TFLOGSTRING("TSY:CSatMoSmsCtrl::SendMoSmsCtrlEnvelope");

    // Get location info

    const CSatMessHandler::TLocationInfo& locInfo

        = iSatMessHandler->LocationInfo();

    // A SwDataNtf is expected later

    iWaitingForEnvelopeResp = ETrue;