/*

* Copyright (c) 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:   ?Description

*

*/

// INCLUDE FILES

#include "cmmuiccmesshandler.h"

#include "cmmphonetsender.h"

#include "tsylogger.h"

#include "cmmmessagerouter.h"

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <e32cmn.h>

#include <pn_const.h>

#include <uiccisi.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmuiccmesshandlerTraces.h"

#endif

// LOCAL CONSTANTS AND MACROS

const TUint8 KUiccPadding( 0 );

const TUint8 KUiccSbApplPathSize( SIZE_UICC_SB_APPL_PATH + KFilePathLength );

const TUint8 KUiccSbFileDataSize( SIZE_UICC_SB_FILE_DATA + KFileDataLength );

const TUint8 KUiccApplCmdReqOffset( ISI_HEADER_SIZE + SIZE_UICC_APPL_CMD_REQ );

const TUint8 KUiccRecordNotDefined( 0 );

const TUint16 KUiccFileIdNotDefined( 0 );

const TUint8 KUiccServiceTypeNotDefined( 0 );

const TUint8 KUiccApduReqSubblockOffset(ISI_HEADER_SIZE + SIZE_UICC_APDU_REQ);

const TUint8 KUiccSbApduLengthOffset( 6 );

const TUint8 KUiccSbApduDataOffset( 8 );

const TUint16 KUiccSbApduSize( SIZE_UICC_SB_APDU + KApduDataLength );

// ============================= LOCAL FUNCTIONS ===============================

void CMmUiccMessHandler::SendTerminalProfile()

    {

    // Temporary for testing purposes, terminal profile sending will be moved

    // to SAT TSY

TFLOGSTRING("TSY: CMmUiccMessHandler::SendTerminalProfile TEMPORARY SOLUTION FOR TESTING");

OstTrace0( TRACE_NORMAL, CMMUICCMESSHANDLER_SENDTERMINALPROFILE, "CMmUiccMessHandler::SendTerminalProfile TEMPORARY SOLUTION FOR TESTING" );

    // Create UICC_CAT_TERMINAL_PROFILE message

    TIsiSend isiMsg( iPhoNetSender->SendBufferDes() );

    isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );

    isiMsg.Set8bit( ISI_HEADER_SIZE, UICC_CAT_REQ_OFFSET_TRANSID ); // transaction id

    isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_CAT_REQ_OFFSET_MESSAGEID, UICC_CAT_REQ );

    isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_CAT_REQ_OFFSET_SERVICETYPE, UICC_CAT_TERMINAL_PROFILE );

    isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_CAT_REQ_OFFSET_NSB, 1 ); // num of subblocks

    // Create subblock

    TBuf8<30> terminalProfileBuf( 0 );

    TIsiSubBlock uiccSbTerminalProfile(

        terminalProfileBuf,

        UICC_SB_TERMINAL_PROFILE,

        EIsiSubBlockTypeId16Len16 );

    // 2x filler

    terminalProfileBuf.Append( KUiccPadding );

    terminalProfileBuf.Append( KUiccPadding );

    // Terminal profile length (16-bit)

    terminalProfileBuf.Append( KUiccPadding );

    terminalProfileBuf.Append( 1 );

    terminalProfileBuf.Append( 0 );

    // Append subblock to ISI message

    isiMsg.CopyData(

        ISI_HEADER_SIZE + 4,

        uiccSbTerminalProfile.CompleteSubBlock() );

    iPhoNetSender->Send( isiMsg.Complete() );

    }

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

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

// TUiccParamsBase::TUiccParamsBase

// Constructor

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

//

TUiccParamsBase::TUiccParamsBase()

    {

    // Initialize data

    messHandlerPtr = NULL;

    trId = ETrIdNotDefined;

    fileId = KUiccFileIdNotDefined;

    fileIdSfi = UICC_SFI_NOT_PRESENT;

    serviceType = KUiccServiceTypeNotDefined;

    filePath.Append( KNullDesC8 );

    }

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

// TUiccApplFileInfo::TUiccApplFileInfo

// Constructor

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

//

TUiccApplFileInfo::TUiccApplFileInfo()

    {

    // None

    }

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

// TUiccReadTransparent::TUiccReadTransparent

// Constructor

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

//

TUiccReadTransparent::TUiccReadTransparent()

    {

    dataOffset = 0;

    dataAmount = 0;

    }

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

// TUiccWriteTransparent::TUiccWriteTransparent

// Constructor

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

//

TUiccWriteTransparent::TUiccWriteTransparent()

    {

    fileData.Append( KNullDesC8 );

    }

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

// TUiccReadLinearFixed::TUiccReadLinearFixed

// Constructor

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

//

TUiccReadLinearFixed::TUiccReadLinearFixed()

    {

    record = KUiccRecordNotDefined;

    }

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

// TUiccWriteLinearFixed::TUiccWriteLinearFixed

// Constructor

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

//

TUiccWriteLinearFixed::TUiccWriteLinearFixed()

    {

    fileData.Append( KNullDesC8 );

    }

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

// TUiccSendApdu::TUiccSendApdu

// Constructor

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

//

TUiccSendApdu::TUiccSendApdu():TUiccParamsBase()

    {

    apdu.Append( KNullDesC8 );

    }

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

// TUiccParamsApduReq::TUiccParamsApduReq

// Constructor

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

//

TUiccParamsApduReq::TUiccParamsApduReq():TUiccParamsBase()

    {

    action = KUiccRecordNotDefined;

    apduData.Append( KNullDesC8 );

    }

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

// CMmUiccMessHandler::CMmUiccMessHandler

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

// might leave.

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

//

CMmUiccMessHandler::CMmUiccMessHandler()

    {

    }

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

// CMmUiccMessHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmUiccMessHandler::ConstructL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver)

    {

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

OstTrace0( TRACE_NORMAL, CMMUICCMESSHANDLER_CONSTRUCTL, "CMmUiccMessHandler::ConstructL" );

    // Reset the pointer array

    iMessHandlerPrtList.Reset();

    iPhoNetSender = aPhoNetSender;

    aPhoNetReceiver->RegisterL( this, PN_UICC );

    iCardType = UICC_CARD_TYPE_UNKNOWN;

    iApplicationId = UICC_APPL_ID_UNKNOWN;

    iApplicationType = UICC_APPL_TYPE_UNKNOWN;

    iApplicationStatus = UICC_STATUS_APPL_NOT_ACTIVE;

    iUiccServerStatus = UICC_STATUS_NOT_READY;

    iUiccClientId = 0;

    iUiccIsimClientId = 0;

    iIsimApplicationId = UICC_APPL_ID_UNKNOWN;

    iIsimApplicationStatus = UICC_STATUS_APPL_NOT_ACTIVE;

    iIsimApplicationFound = EFalse;

    iPin1Id = 0;

    iPin2Id = 0;

    iActivePin = RMobilePhone::ESecurityCodePin1;

    iAid.Zero();

    // Initialized for USIM application

    iApplFileId.Append( 0x7F );

    iApplFileId.Append( 0xFF );

    }

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

// CMmUiccMessHandler::NewL

// Two-phased constructor.

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

//

CMmUiccMessHandler* CMmUiccMessHandler::NewL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver,

    CMmMessageRouter* aMessageRouter )

    {

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

OstTrace0( TRACE_NORMAL, CMMUICCMESSHANDLER_NEWL, "CMmUiccMessHandler::NewL" );

    CMmUiccMessHandler* uiccMessHandler( new ( ELeave ) CMmUiccMessHandler() );

    CleanupStack::PushL( uiccMessHandler );

    uiccMessHandler->iMessageRouter = aMessageRouter;

    uiccMessHandler->ConstructL( aPhoNetSender, aPhoNetReceiver );

    CleanupStack::Pop( uiccMessHandler );

    return uiccMessHandler;

    }

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

// CMmUiccMessHandler::~CMmUiccMessHandler()

// Destructor

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

//

CMmUiccMessHandler::~CMmUiccMessHandler()

    {

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

OstTrace0( TRACE_NORMAL, CMMUICCMESSHANDLER_CMMUICCMESSHANDLER, "CMmUiccMessHandler::~CMmUiccMessHandler" );

    }

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

// CMmUiccMessHandler::ReceiveMessageL

// Receive ISI messages from phonet

// (other items were commented in a header).

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

//

void CMmUiccMessHandler::ReceiveMessageL( const TIsiReceiveC& aIsiMsg )

    {

    TInt status( KErrNone );

    TUint8 messageId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    TUint8 trId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );

    TUint8 serviceType( 0 );

    TPtrC8 fileData;

TFLOGSTRING3("TSY: CMmUiccMessHandler::ReceiveMessageL, message ID :0x%x, transaction ID: %d", messageId, trId );

OstTraceExt2( TRACE_NORMAL, CMMUICCMESSHANDLER_RECEIVEMESSAGEL, "CMmUiccMessHandler::ReceiveMessageL;messageId=%hhx;trId=%hhu", messageId, trId );

    // Get the correct message handler for this operation

    MUiccOperationBase* messHandler( iMessHandlerPrtList.At( trId ) );

    switch( messageId )

        {

        case UICC_CAT_IND:

            {

            // Send terminal profile ( to be moved to SAT TSY later )

            SendTerminalProfile();

            break;

            }

        case UICC_CAT_RESP:

            {

            // To be moved to SAT TSY later

            break;

            }

        case UICC_CARD_IND:

            {

            serviceType = aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_CARD_IND_OFFSET_SERVICETYPE );

            // Start application activation procedure if the card is ready and

            // the application is not active yet

            if ( UICC_CARD_READY == serviceType &&

                UICC_STATUS_APPL_ACTIVE != iApplicationStatus )

                {

                TUiccParamsBase params;

                params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );

                params.trId = ETrIdGetUiccApplication;

                CreateUiccApplicationReq( params, UICC_APPL_LIST );

                }

            // No else. Application was active already

            break;

            }

        case UICC_RESP:

            {

            iUiccServerStatus = HandleUiccResp( aIsiMsg );

            // Start application activation procedure if the card is ready and

            // the application is not active yet

            if ( UICC_STATUS_START_UP_COMPLETED == iUiccServerStatus &&

                UICC_STATUS_APPL_ACTIVE != iApplicationStatus)

                {

                // Read the application ID

                TUiccParamsBase params;

                params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );

                params.trId = ETrIdGetUiccApplication;

                CreateUiccApplicationReq( params, UICC_APPL_LIST );

                }

            break;

            }

        case UICC_APPLICATION_RESP:

            {

            status = HandleUiccApplicationResp( aIsiMsg );

            break;

            }

        case UICC_APPLICATION_IND:

            {

            TInt8 serviceType( aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APPLICATION_IND_OFFSET_SERVICETYPE ) );

            iApplicationStatus = UICC_STATUS_APPL_ACTIVE;

            // Application activation indication with service type

            // UICC_APPL_ACTIVATED, as part of PowerOnSim sequence.

            // Transaction id is set to ETrIdSimPowerOn and operation

            // is added to list and flag is disabled.

            if( UICC_APPL_ACTIVATED == serviceType )

                {

                iDoNotRemoveTransactionID = EFalse;

                status = KErrNone;

                trId = ETrIdSimPowerOn;

                messHandler = iMessHandlerPrtList.At( trId );

                }

            break;

            }

        case UICC_APPL_CMD_RESP:

            {

            status = aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APPL_CMD_RESP_OFFSET_STATUS );

            TInt8 serviceType( aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APPL_CMD_RESP_OFFSET_SERVICETYPE ) );

            if ( UICC_STATUS_OK == status )

                {

                // If READ operation was required, read data from subblock

                if ( UICC_APPL_READ_TRANSPARENT == serviceType ||

                   UICC_APPL_READ_LINEAR_FIXED == serviceType )

                    {

                    fileData.Set( GetFileData( aIsiMsg ) );

                    }

                if ( UICC_APPL_FILE_INFO == serviceType )

                    {

                    fileData.Set( GetFileFCI( aIsiMsg ) );

                    }

                if ( UICC_APPL_APDU_SEND == serviceType )

                    {

                    fileData.Set( GetApduData( aIsiMsg ) );

                    }

                }

            else

                {

TFLOGSTRING2("TSY: CMmUiccMessHandler::ReceiveMessageL, case UICC_APPL_CMD_RESP, status: %d", status );

OstTraceExt1( TRACE_NORMAL, DUP1_CMMUICCMESSHANDLER_RECEIVEMESSAGEL, "CMmUiccMessHandler::ReceiveMessageL, case UICC_APPL_CMD_RESP;status=%hhu", status );

                }

            break;

            }

        case UICC_APDU_RESP:

            {

            status = aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APDU_RESP_OFFSET_STATUS );

            TInt8 serviceType( aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APDU_RESP_OFFSET_SERVICETYPE ) );

            // Extract actual APDU from SB_APDU

            if( UICC_STATUS_OK == status )

                {

                if( UICC_APDU_ATR_GET == serviceType

                    || UICC_APDU_SEND == serviceType )

                    {

                    fileData.Set( GetApduData( aIsiMsg ) );

                    }

                }

            break;

            }

        case UICC_APDU_RESET_IND:

            {

            TInt8 serviceType( aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_APDU_RESET_IND_OFFSET_SERVICETYPE ) );

            // Indication that SAP APDU interface is activated

            if( UICC_READY == serviceType )

                {

                // Disable flag

                iDoNotRemoveTransactionID = EFalse;

                status = KErrNone;

                }

            break;

            }

        case UICC_CONNECTOR_RESP:

            {

            status = aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_CONNECTOR_RESP_OFFSET_STATUS );

            }

            break;

        case UICC_CARD_RESP:

            {

            status = aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_CARD_RESP_OFFSET_STATUS );

            TUint8 serviceType( aIsiMsg.Get8bit(

                ISI_HEADER_SIZE + UICC_CARD_RESP_OFFSET_SERVICETYPE ) );

            if( UICC_STATUS_OK == status

                && UICC_CARD_STATUS_GET  == serviceType )

                {

                // File data from SIZE_UICC_SB_CARD_STATUS

                TUint uiccSbFileDataOffset( 0 );

                TInt cardStatusFieldLength( 1 );

                if ( KErrNone == aIsiMsg.FindSubBlockOffsetById(

                    ISI_HEADER_SIZE + SIZE_UICC_CARD_RESP,

                    UICC_SB_CARD_STATUS,

                    EIsiSubBlockTypeId16Len16,

                    uiccSbFileDataOffset ) )

                    {

                    fileData.Set(aIsiMsg.GetData(

                        uiccSbFileDataOffset +

                        UICC_SB_CARD_STATUS_OFFSET_CARDSTATUS,

                        cardStatusFieldLength) );

                    }

                }

            }

            break;

        default:

            {

TFLOGSTRING("TSY: CMmUiccMessHandler::ReceiveMessageL, default" );

OstTrace0( TRACE_NORMAL, DUP2_CMMUICCMESSHANDLER_RECEIVEMESSAGEL, "CMmUiccMessHandler::ReceiveMessageL, default" );

            break;

            }

        }

    if ( NULL != messHandler )

        {

        if( !iDoNotRemoveTransactionID )

            {

            iMessHandlerPrtList[trId] = NULL;

            }

        messHandler->ProcessUiccMsg( trId, status, fileData );

        }

    else

        {

TFLOGSTRING("TSY: CMmUiccMessHandler::ReceiveMessageL, message handler not found -> no further handling of this message" );

OstTrace0( TRACE_NORMAL, DUP3_CMMUICCMESSHANDLER_RECEIVEMESSAGEL, "CMmUiccMessHandler::ReceiveMessageL, message handler not found -> no further handling of this message" );

        }

    }

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

// CMmUiccMessHandler::CreateUiccApplCmdReq

// (other items were commented in a header).

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

//

TInt CMmUiccMessHandler::CreateUiccApplCmdReq(

    const TUiccParamsBase& aParams,

    const TUint8 aApplType )

    {

    TInt ret( KErrNone );

    TInt trId( aParams.trId );

    TInt8 serviceType( aParams.serviceType );

    TUint8 numOfSubblocks( 0 );

    TUint8 sizeOfApplPathSubblock( 0 );

TFLOGSTRING2("TSY: CMmUiccMessHandler::CreateUiccApplCmdReq, transaction ID: %d", trId );

OstTrace1( TRACE_NORMAL, CMMUICCMESSHANDLER_CREATEUICCAPPLCMDREQ, "CMmUiccMessHandler::CreateUiccApplCmdReq;trId=%d", trId );

    TUint8 applId( aApplType == UICC_APPL_TYPE_UICC_ISIM ?

        iIsimApplicationId : iApplicationId );

    // If there is the previous request ongoing (pointer was already set for

    // this operation)  we can't handle this request.

    if ( NULL == iMessHandlerPrtList.At( trId ) )

        {

        // Save pointer to message handler, it is needed when receiving

        // respone for this operation

        iMessHandlerPrtList[trId] = aParams.messHandlerPtr;

        // Create UICC_APPL_CMD_REQ message

        TIsiSend isiMsg( iPhoNetSender->SendBufferDes() );

        isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_TRANSID,

            trId );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_MESSAGEID,

            UICC_APPL_CMD_REQ );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_SERVICETYPE,

            serviceType );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_APPLID,

            applId );

        isiMsg.Set8bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_SESSIONID,

            UICC_SESSION_ID_NOT_USED );

        isiMsg.Set16bit(

            ISI_HEADER_SIZE + UICC_APPL_CMD_REQ_OFFSET_FILLERBYTE1,

            KUiccPadding );

        switch ( serviceType )

            {

            case UICC_APPL_READ_TRANSPARENT:

                {

                numOfSubblocks = 3;

                // Create and append UICC_SB_CLIENT

                CreateUiccSbClient( isiMsg, KUiccApplCmdReqOffset );

                // Create and append UICC_SB_TRANSPARENT

                CreateUiccSbTransparent(