/*

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

#include <nsisi.h>

#include "tsylogger.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmpipecontrolTraces.h"

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

    }

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

// CMmPipeControl::~CMmPipeControl

// Destructor, deletes all allocated resources.

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

//

CMmPipeControl::~CMmPipeControl()

    {

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

    }

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

// CMmPipeControl::NewL

// Two-phased constructor.

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

//

CMmPipeControl* CMmPipeControl::NewL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver,

    CMmPacketContextMessHandler* aMmPacketContextMessHandler,

    CMmPacketContextMesshandlerList* aMmPacketContextMesshandlerList)

    {

    TFLOGSTRING("TSY: 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

    CleanupStack::Pop( mmPipeControl );

    return mmPipeControl;

    }

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

// CMmPipeControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmPipeControl::ConstructL()

    {

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

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

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

    InitLists();

    }

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

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

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

                    break;

                    }

                }

            break;

            }

        default:

            {

            TFLOGSTRING2("TSY: 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");

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

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

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

    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");

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

    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;

    }

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

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

    // create buffer for isi msg data

    TBuf8<SIZE_PNS_PIPE_CREATE_REQ> data;

    // set message data

    data.Append( aPipeState );

    data.Append( KGpdsPadding );

    data.Append( KFirstPepDevice );

    data.Append( aFirstPepObject );

    data.Append( KFirstPepType );

    data.Append( KGpdsPadding );

    data.Append( iSecondPepDeviceId );

    data.Append( iSecondPepObjectId );

    data.Append( KSecondPepType );

    data.Append( KGpdsPadding );

    // Sending message to phonet

    return iPhoNetSender->Send(

        PN_PIPE, aTransId, PNS_PIPE_CREATE_REQ, data );

    }

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

// CMmPipeControl::PnsPipeCreateResp

// Breaks a PNS_PIPE_CREATE_RESP ISI-message.

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

//

void CMmPipeControl::PnsPipeCreateResp(

    const TIsiReceiveC& aIsiMessage )

    {

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

    // Get transaction Id

    TUint8 transId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );

    TInt ret = iContextList->PipeCreateTransIdOkByTransId( transId );

    if ( KErrNone == ret )

        {

        TUint8 pipeHandle( aIsiMessage.Get8bit(

            ISI_HEADER_SIZE + PNS_PIPE_CREATE_RESP_OFFSET_PIPEHANDLE ) );

        TUint8 errorCode( aIsiMessage.Get8bit(

            ISI_HEADER_SIZE + PNS_PIPE_CREATE_RESP_OFFSET_ERRORCODE ) );

        TFLOGSTRING4("TSY: CMmPipeControl::PnsPipeCreateResp. TransactionId: %d, PipeHandle: %d, error code: %d", transId, pipeHandle, errorCode );

        // Check PIPE Error Code

        if ( PN_PIPE_ERR_GENERAL == errorCode )

            {

            TUint8 pep1ErrorCode( aIsiMessage.Get8bit(

                ISI_HEADER_SIZE + PNS_PIPE_CREATE_RESP_OFFSET_PEP1ERRORCODE ) );

            TUint8 pep2ErrorCode( aIsiMessage.Get8bit(

                ISI_HEADER_SIZE + PNS_PIPE_CREATE_RESP_OFFSET_PEP2ERRORCODE ) );

             // Check PEP Error Codes

           if ( pep1ErrorCode == PN_PIPE_ERR_PEP_IN_USE ||

                 pep1ErrorCode == PN_PIPE_ERR_ALL_PIPES_IN_USE ||

                 pep2ErrorCode == PN_PIPE_ERR_PEP_IN_USE ||

                 pep2ErrorCode == PN_PIPE_ERR_ALL_PIPES_IN_USE )

                {

                TFLOGSTRING("TSY: CMmPipeControl::PnsPipeCreateResp. ErrorCode changed to PN_PIPE_ERR_ALL_PIPES_IN_USE" );

                // PEP can't create more pipes (all pipes in use),

                // error value is updated here

                errorCode = PN_PIPE_ERR_ALL_PIPES_IN_USE;

                }

            //no else

            }

        //no else

        iContextMessHandler->CompletePipeOperation(

            PNS_PIPE_CREATE_RESP,

            transId,

            pipeHandle,

            errorCode );

        }

    //no else

    }

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

// CMmPipeControl::PnsPipeEnableReq

// Construct a PNS_PIPE_ENABLE_REQ ISI-message.

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

//

TInt CMmPipeControl::PnsPipeEnableReq(

    {

    TInt ret( KErrServerBusy );

        {