/*

* Copyright (c) 2007-2008 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:

*

*/

// INCLUDES

#include "cmmpipecontrol.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmpacketservicemesshandler.h"

#include "cmmpacketmesshandlercontextlist.h"

#include <tisi.h>

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

#include <nsisi.h>

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

#include "tsylogger.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

    // None

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

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

    // None

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

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

// CMmPipeControl::CMmPipeControl

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

// might leave.

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

//

CMmPipeControl::CMmPipeControl()

    {

    TFLOGSTRING("TSY: CMmPipeControl::CMmPipeControl");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_CMMPIPECONTROL, "CMmPipeControl::CMmPipeControl" );

    }

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

// CMmPipeControl::~CMmPipeControl

// Destructor, deletes all allocated resources.

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

//

CMmPipeControl::~CMmPipeControl()

    {

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

OstTrace0( TRACE_NORMAL, DUP1_CMMPIPECONTROL_CMMPIPECONTROL, "CMmPipeControl::~CMmPipeControl" );

    }

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

// CMmPipeControl::NewL

// Two-phased constructor.

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

//

CMmPipeControl* CMmPipeControl::NewL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver,

    CMmPacketContextMessHandler* aMmPacketContextMessHandler,

    CMmPacketContextMesshandlerList* aMmPacketContextMesshandlerList)

    {

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

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_NEWL, "CMmPipeControl::NewL" );

    CMmPipeControl* mmPipeControl = new ( ELeave ) CMmPipeControl();

    CleanupStack::PushL( mmPipeControl );

    mmPipeControl->iPhoNetSender = aPhoNetSender;

    mmPipeControl->iContextMessHandler = aMmPacketContextMessHandler;

    mmPipeControl->iContextList = aMmPacketContextMesshandlerList;

    mmPipeControl->ConstructL();

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PIPE_CREATE_RESP );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PIPE_ENABLE_RESP );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PIPE_RESET_RESP );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PIPE_REMOVE_RESP );

#ifdef DUMMY_NIF_PEP_FOR_PACKET_DATA_TESTING_DOS

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PEP_CONNECT_REQ );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PEP_DISCONNECT_REQ );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PEP_RESET_REQ );

    aPhoNetReceiver->RegisterL( mmPipeControl, PN_PIPE, PNS_PEP_ENABLE_REQ );

#endif //DUMMY_NIF_PEP_FOR_PACKET_DATA_TESTING_DOS

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   aPhoNetReceiver->

        RegisterL( mmPipeControl, PN_NAMESERVICE, PNS_NAME_QUERY_RESP );

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

    CleanupStack::Pop( mmPipeControl );

    return mmPipeControl;

    }

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

// CMmPipeControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmPipeControl::ConstructL()

    {

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

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_CONSTRUCTL, "CMmPipeControl::ConstructL" );

    iSecondPepDeviceId = KSecondPepDevice; // Default Device Id of second PEP

    iSecondPepObjectId = KSecondPepObject; // Default Object Id of second PEP

    InitLists();

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   PnsNameQueryReq();

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

    }

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

// CMmPipeControl::ReceiveMessageL

// Entry point for messages received from Domestic OS.

// Switches the message to the correct method.

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

//

void CMmPipeControl::ReceiveMessageL( const TIsiReceiveC& aIsiMessage )

    {

    TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

    TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    TFLOGSTRING3("TSY: CMmPipeControl::ReceiveMessageL - resource: %d, msgId: %d", resource, messageId);

OstTraceExt2( TRACE_NORMAL, CMMPIPECONTROL_RECEIVEMESSAGEL, "CMmPipeControl::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId );

    switch ( resource )

        {

        case PN_PIPE:

            {

            switch( messageId )

                {

                case PNS_PIPE_CREATE_RESP:

                    {

                    PnsPipeCreateResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_ENABLE_RESP:

                    {

                    PnsPipeEnableResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_RESET_RESP:

                    {

                    PnsPipeResetResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_REMOVE_RESP:

                    {

                    PnsPipeRemoveResp( aIsiMessage );

                    break;

                    }

#ifdef DUMMY_NIF_PEP_FOR_PACKET_DATA_TESTING_DOS

                case PNS_PEP_CONNECT_REQ:

                    {

                    PnsPepConnectReq( aIsiMessage );

                    break;

                    }

                case PNS_PEP_DISCONNECT_REQ:

                    {

                    PnsPepDisconnectReq( aIsiMessage );

                    break;

                    }

                case PNS_PEP_RESET_REQ:

                    {

                    PnsPepResetReq( aIsiMessage );

                    break;

                    }

                case PNS_PEP_ENABLE_REQ:

                    {

                    PnsPepEnableReq( aIsiMessage );

                    break;

                    }

#endif // DUMMY_NIF_PEP_FOR_PACKET_DATA_TESTING_DOS

                default:

                    {

                    TFLOGSTRING2("TSY: CMmPipeControl::ReceiveMessageL - PN_PIPE - unknown msgId: %d", messageId);

OstTrace1( TRACE_NORMAL, DUP1_CMMPIPECONTROL_RECEIVEMESSAGEL, "CMmPipeControl::ReceiveMessageL;unknown messageId=%d", messageId );

                    break;

                    }

                }

            break;

            }

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

        case PN_NAMESERVICE:

            {

            switch( messageId )

                {

                case PNS_NAME_QUERY_RESP:

                    {

                    PnsNameQueryResp( aIsiMessage );

                    break;

                    }

                default:

                    {

                    TFLOGSTRING2("TSY: CMmPipeControl::ReceiveMessageL - PN_NAMESERVICE - unknown msgId: %d", messageId);

OstTrace1( TRACE_NORMAL, DUP2_CMMPIPECONTROL_RECEIVEMESSAGEL, "CMmPipeControl::ReceiveMessageL;unknown messageId=%d", messageId );

                    break;

                    }

                }

            break;

            }

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        default:

            {

            TFLOGSTRING2("TSY: CMmPipeControl::ReceiveMessageL - unknown resource: %d", resource);

OstTrace1( TRACE_NORMAL, DUP3_CMMPIPECONTROL_RECEIVEMESSAGEL, "CMmPipeControl::ReceiveMessageL;unknown resource=%d", resource );

            break; // server not known

            }

        } // end of switch

    }

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

// CMmPipeControl::InitLists

// Initialize used lists and attributes.

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

//

void CMmPipeControl::InitLists()

    {

    TFLOGSTRING("TSY: CMmPipeControl::InitLists");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_INITLISTS, "CMmPipeControl::InitLists" );

    // Find PipeHandle id from Pipe Operation by PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        // Initialize pipe operation array

        iPipeOperationArray[i].iPipeHandle = KInvalidPipeHandle;

        // Use zero as default value

        iPipeOperationArray[i].iTransId = 0;

        }

    }

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

// CMmPipeControl::SetPipeHandle

// Set Pipe Handle value to the list.

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

//

void CMmPipeControl::SetPipeHandle(

    const TUint8 aPipeHandle )

    {

    TFLOGSTRING("TSY: CMmPipeControl::SetPipeHandle");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_SETPIPEHANDLE, "CMmPipeControl::SetPipeHandle" );

    // Find PipeHandle id from Pipe Operation by PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        // If KInvalidPipeHandle is same as in iPipeOperationArray list

        if ( KInvalidPipeHandle == iPipeOperationArray[i].iPipeHandle )

            {

            // Set pipehandle to the pipe operation list

            iPipeOperationArray[i].iPipeHandle = aPipeHandle;

            // Pipe handle found, break

            i = KMmMaxNumberOfPipeHandles;

            }

        //no else

        }

    }

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

// CMmPipeControl::SetTransactionId

// If pipehandle found set transaction id value to the list.

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

//

void CMmPipeControl::SetTransactionId(

    const TUint8 aPipeHandle,

    const TUint8 aTransId )

    {

    TFLOGSTRING("TSY: CMmPipeControl::SetTransactionId");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_SETTRANSACTIONID, "CMmPipeControl::SetTransactionId" );

    // Find PipeHandle id from Pipe Operation by PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        // If aPipeHandle is same as in iPipeOperationArray list

        if ( aPipeHandle == iPipeOperationArray[i].iPipeHandle )

            {

            // Set aTransId to the pipe operation list

            iPipeOperationArray[i].iTransId = aTransId;

            // Pipe handle found, break

            i = KMmMaxNumberOfPipeHandles;

            }

        //no else

        }

    }

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

// CMmPipeControl::TransactionId

// Returns Transaction id by PipeHandle.

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

//

TUint8 CMmPipeControl::TransactionId(

    const TUint8 aPipeHandle ) const

    {

    TFLOGSTRING("TSY: CMmPipeControl::TransactionId");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_TRANSACTIONID, "CMmPipeControl::TransactionId" );

    TUint8 transId( 0 );

    // Find PipeHandle from Pipe Operation by PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        // If aPipeHandle is same as in iPipeOperationArray list

        if ( aPipeHandle == iPipeOperationArray[i].iPipeHandle )

            {

            // Get transaction id from the PipeOperationArray list

            transId = iPipeOperationArray[i].iTransId;

            // Pipe handle found, break

            i = KMmMaxNumberOfPipeHandles;

            }

        //no else

        }

    // Return Transaction id

    return transId;

    }

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

// CMmPipeControl::ResetPipeHandle

// Remove Pipehandle and Transaction id from the list.

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

//

void CMmPipeControl::ResetPipeHandle(

    const TUint8 aPipeHandle )

    {

    TFLOGSTRING("TSY: CMmPipeControl::ResetPipeHandle");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_RESETPIPEHANDLE, "CMmPipeControl::ResetPipeHandle" );

    // Find PipeHandle id from Pipe Operation by PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        // If aPipeHandle is same as in iPipeOperationArray list

        if ( aPipeHandle == iPipeOperationArray[i].iPipeHandle )

            {

            // Initialize Pipehandle to KInvalidPipeHandle

            iPipeOperationArray[i].iPipeHandle = KInvalidPipeHandle;

            // initialize TransactionId to zero

            iPipeOperationArray[i].iTransId = 0;

            // Pipe handle found, break

            i = KMmMaxNumberOfPipeHandles;

            }

        //no else

        }

    }

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

// CMmPipeControl::IsOperationCalled

// Check if pipe operation for given pipe is outgoing

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

//

TBool CMmPipeControl::IsOperationCalled(

    const TUint8 aPipeHandle ) const

    {

    TFLOGSTRING("TSY: CMmPipeControl::IsOperationCalled");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_ISOPERATIONCALLED, "CMmPipeControl::IsOperationCalled" );

    TBool ret( EFalse);

    // Find PipeHandle id from PipeHandle List

    for ( TInt i = 0; i < KMmMaxNumberOfPipeHandles; i++ )

        {

        if ( aPipeHandle == iPipeOperationArray[i].iPipeHandle )

            {

            // PipeHandle id found, return true

            ret = ETrue;

            }

        }

    // PipeHandle id not found, return false

    return ret;

    }

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

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

// CMmPipeControl::PnsNameQueryReq

// Construct a PNS_NAME_QUERY_REQ ISI-message

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

//

TInt CMmPipeControl::PnsNameQueryReq() const

    {

    TFLOGSTRING("TSY: CMmPipeControl::PnsNameQueryReq");

OstTrace0( TRACE_NORMAL, CMMPIPECONTROL_PNSNAMEQUERYREQ, "CMmPipeControl::PnsNameQueryReq" );

    // create buffer for isi msg data

    TBuf8<SIZE_PNS_NAME_QUERY_REQ> data;

    // set message data

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( PN_GPRS  ); // Gprs server

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( KGpdsPadding ); // Padding byte

    data.Append( PN_GPRS  ); // Gprs server

    // set dummyTransactionId value to 0x0F

    TUint8 dummyTransactionId( KDummyTrId );

    // Sending message to phonet

    return iPhoNetSender->Send(

        PN_NAMESERVICE, dummyTransactionId, PNS_NAME_QUERY_REQ, data );

    }

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

// CMmPipeControl::PnsNameQueryResp

// Breaks a PNS_NAME_QUERY_RESP ISI-message

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

//

void CMmPipeControl::PnsNameQueryResp(

    const TIsiReceiveC& aIsiMessage )

    {

    TUint16 matchesInThisMsg( aIsiMessage.Get16bit(

        ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG ) );

    TFLOGSTRING2("TSY: CMmPipeControl::PnsNameQueryResp - matches in this msg: %d", matchesInThisMsg);

OstTraceExt1( TRACE_NORMAL, CMMPIPECONTROL_PNSNAMEQUERYRESP, "CMmPipeControl::PnsNameQueryResp;matchesInThisMsg=%hu", matchesInThisMsg );

    if ( 0 < matchesInThisMsg )

        {

        for ( TInt i = 0; i < matchesInThisMsg; i++ )

            {

            // each match is represented as 8-byte record =>

            // recordIndex = i * SIZE_PN_NAME_SRV_ITEM_STR

            // name is 4 bytes =>

            // last byte index = PN_NAME_SRV_ITEM_STR_OFFSET_NAME + KLastByteIndex

            TInt recordIndex( i * SIZE_PN_NAME_SRV_ITEM_STR );

            TUint8 name( aIsiMessage.Get8bit(

                ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL +

                recordIndex + ( PN_NAME_SRV_ITEM_STR_OFFSET_NAME + KLastByteIndex ) ) );

            if ( PN_GPRS == name )

                {

                // Get and store SecondPepDevice id and SecondPepObject id

                iSecondPepDeviceId = aIsiMessage.Get8bit(

                    ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL +

                    recordIndex + PN_NAME_SRV_ITEM_STR_OFFSET_DEV );

                iSecondPepObjectId = aIsiMessage.Get8bit(

                    ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL +

                    recordIndex + PN_NAME_SRV_ITEM_STR_OFFSET_OBJ );

                // then find right server, stop finding

                i = matchesInThisMsg;

                TFLOGSTRING3("TSY: CMmPipeControl::PnsNameQueryResp. SecondPepDeviceId: %d SecondPepObjectId: %d", iSecondPepDeviceId, iSecondPepObjectId );

OstTraceExt2( TRACE_NORMAL, DUP1_CMMPIPECONTROL_PNSNAMEQUERYRESP, "CMmPipeControl::PnsNameQueryResp;iSecondPepDeviceId=%hhu;iSecondPepObjectId=%hhu", iSecondPepDeviceId, iSecondPepObjectId );

                }

            //no else

            }

        }

    //no else

    }

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

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

// CMmPipeControl::PnsPipeCreateReq

// Construct a PNS_PIPE_CREATE_REQ ISI-message

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

//

TInt CMmPipeControl::PnsPipeCreateReq(

    const TUint8 aTransId,

    const TUint8 aPipeState,

    const TUint8 aFirstPepObject ) const

    {

    TFLOGSTRING2("TSY: CMmPipeControl::PnsPipeCreateReq. TransactionId: %d", aTransId );

OstTraceExt1( TRACE_NORMAL, CMMPIPECONTROL_PNSPIPECREATEREQ, "CMmPipeControl::PnsPipeCreateReq;aTransId=%hhu", aTransId );

    // create buffer for isi msg data

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

    TBuf8<SIZE_PNS_PIPE_CREATE_REQ> data;

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

    TBuf8<SIZE_CM_PIPE_CREATE_REQ> data;