/*

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

*

*/

// INCLUDE FILES

#include <tisi.h>

#include <nsisi.h>      // isi name

#include <pipeisi.h>    // isi pipe

#include <pipe_sharedisi.h>

#include "dpdef.h"      // dataport definitions

#include "dpdataport.h" // dataport main and c32 interface

#include "dpmif.h"      // message interface mif

#include "dppif.h"      // pipe interface pif

#include "dpcommpep.h"  // comm pep interface. interaction with mif

#include "dplog.h"      // dataport logging

#include "osttracedefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "dpmiftraces.h"

#endif

// EXTERNAL DATA STRUCTURES

// none

// EXTERNAL FUNCTION PROTOTYPES

// none

// CONSTANTS

#ifdef OST_TRACE_COMPILER_IN_USE

const TUint8 KBufferForOSTTracing = 100;

#endif

// MACROS

// none

// LOCAL CONSTANTS AND MACROS

// none

// MODULE DATA STRUCTURES

// none

// LOCAL FUNCTION PROTOTYPES

// none

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

// Local function for printing ISI message in OST

#ifdef OST_TRACE_COMPILER_IN_USE

static void OstPrintIsiMessage( const TDesC8& aBuf )

    {

    _LIT( KTraceSpace, " " );

    TInt length = aBuf.Length();

    TBuf8<KBufferForOSTTracing> trace_msg;

    TUint counter = 1;

    TBool firstTime = ETrue;

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

        {

        trace_msg.AppendNumFixedWidthUC( aBuf[i], EHex, 2 );

        trace_msg.Append( KTraceSpace );

        if ( ( counter > 24 ) ||     // 25 bytes / line

           ( ( i + 1 ) == length ) ) // All bytes collected

            {

            if ( ( firstTime ) &&

               ( ( i + 1 ) == length ) ) // All bytes collected and traced

                {

                firstTime = EFalse;

                OstTraceExt1( TRACE_NORMAL, DUP_OSTPRINTISIMESSAGE, "CDpMif:: ==> [ %s]", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else if ( firstTime ) // 1st line of the trace

                {

                firstTime = EFalse;

                OstTraceExt1( TRACE_NORMAL, DUP1_OSTPRINTISIMESSAGE, "CDpMif:: ==> [ %s", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else if ( ( i + 1 ) == length ) // The last line

                {

                OstTraceExt1( TRACE_NORMAL, DUP2_OSTPRINTISIMESSAGE, "CDpMif:: ==>   %s]", trace_msg );

                trace_msg.SetLength( 0 );

                }

            else // just print bytes

                {

                OstTraceExt1( TRACE_NORMAL, DUP3_OSTPRINTISIMESSAGE, "CDpMif:: ==>   %s", trace_msg );

                trace_msg.SetLength( 0 );

                }

            counter = 0;

            }

        counter++;

        }

    }

#else // OST_TRACE_COMPILER_IN_USE

#define OstPrintIsiMessage(x)

#endif // OST_TRACE_COMPILER_IN_USE

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

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

// CDpMif::NewL

// Static constructor.

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

CDpMif* CDpMif::NewL(

    CDpDataPort& aDataPort )

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_NEWL, "CDpMif::NewL" );

    LOGM(" CDpMif::NewL");

    CDpMif* self = new ( ELeave ) CDpMif( aDataPort );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDpMif::ConstructL

// Symbian 2nd phase constructor.

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

void CDpMif::ConstructL()

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_CONSTRUCTL, "CDpMif::ConstructL" );

    LOGM(" CDpMif::ConstructL");

    iMsgReceiveBuffer = HBufC8::NewL( ISI_HEADER_SIZE + KDpMaxMsgReceiveSize );

    _LIT(KPanicStr, "Dataport - CDpMif::ConstructL");

    __ASSERT_ALWAYS( iMsgReceiveBuffer,

        User::Panic( KPanicStr, KErrNoMemory ) );

    iReceiveMessage.Set( iMsgReceiveBuffer->Des() );

    iReceiveMessage.SetLength( 0 );

    iMessageSendBuffer = HBufC8::NewL( ISI_HEADER_SIZE + KDpMaxMsgSendSize );

    __ASSERT_ALWAYS( iMessageSendBuffer,

        User::Panic( KPanicStr, KErrNoMemory ) );

    iSendMessage.Set( iMessageSendBuffer->Des() );

    iSendMessage.SetLength( 0 );

    }

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

// CDpMif::CDpMif

// C++ default constructor.

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

CDpMif::CDpMif(

    CDpDataPort& aDataPort ) :

    CActive( KDpMifPriority ),

    iDataPort( aDataPort ),

    iPifDcs( iDataPort.Pif() ),

    iCommPep( iDataPort.CommPep() ),

    iMsgReceiveBuffer( NULL ),

    iReceiveMessage( NULL, 0 ),

    iMessageSendBuffer( NULL ),

    iSendMessage( NULL, 0 )

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_CDPMIF, "CDpMif::CDpMif" );

    LOGM(" CDpMif::CDpMif");

    CActiveScheduler::Add( this );

    }

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

// CDpMif::~CDpMif

// Destructor

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

CDpMif::~CDpMif()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CDPMIF_CDPMIF, "CDpMif::~CDpMif" );

    LOGM(" CDpMif::~CDpMif");

    if ( iMsgReceiveBuffer )

        {

        delete iMsgReceiveBuffer;

        }

    //no else

    iMsgReceiveBuffer = NULL;

    iReceiveMessage.Set( NULL, 0, 0 );

    if ( iMessageSendBuffer )

        {

        delete iMessageSendBuffer;

        }

    //no else

    iMessageSendBuffer = NULL;

    iSendMessage.Set( NULL, 0, 0 );

    }

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

// CDpMif::RunL

// This method handles received message from Isc Api and

// renews read from Isc Api.

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

//

void CDpMif::RunL()

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_RUNL, "CDpMif::RunL" );

    LOGM1("CDpMif::RunL - Port %d", iDataPort.PortUnit() );

    // we are always signaled from PhoNet ReceiveMessage

    if ( KErrNoMemory == iStatus.Int() )

        {

        LOGM(" ==> KErrNoMemory");

        OstTrace0( TRACE_NORMAL, DUP1_CDPMIF_RUNL, "CDpMif:: ==> KErrNoMemory" );

        // deallocate current message

        if ( iMsgReceiveBuffer )

            {

            delete iMsgReceiveBuffer;

            iMsgReceiveBuffer = NULL;

            iReceiveMessage.Set( NULL, 0, 0 );

            }

        //no else

        // ISA Handle receive

        // Trying to allocate a new message

        iMsgReceiveBuffer = HBufC8::NewL( ISI_HEADER_SIZE + iLen );

        _LIT( KPanicStr, "Dataport - CDpMif::RunL" );

        __ASSERT_ALWAYS( iMsgReceiveBuffer,

            User::Panic( KPanicStr, KErrNoMemory ) );

        iReceiveMessage.Set( iMsgReceiveBuffer->Des() );

        iLen = 0;

        if ( !IsActive() )

            {

            iDataPort.ISAHandle().Receive(

                iStatus, iReceiveMessage, iLen );

            SetActive();

            }

        //no else

        }

     else

        {

        OstTrace0( TRACE_NORMAL, DUP2_CDPMIF_RUNL, "CDpMif:: ==> ISI-message received" );

        OstPrintIsiMessage( iReceiveMessage );

        LOGM(" ==> ISI-message received");

        LOGMESSAGE( iReceiveMessage );

        TIsiReceiveC receivedMsg( iReceiveMessage );

        TUint8 resource_id( receivedMsg.Get8bit(

            ISI_HEADER_OFFSET_RESOURCEID ) );

        TUint8 message_id( receivedMsg.Get8bit(

            ISI_HEADER_OFFSET_MESSAGEID ) );

        switch ( resource_id )

            {

            case PN_NAMESERVICE:

                {

                switch ( message_id )

                    {

                    case PNS_NAME_ADD_RESP:

                        {

                        LOG(" ==> PNS_NAME_ADD_RESP received");

                        OstTrace0( TRACE_NORMAL, DUP4_CDPMIF_RUNL, "CDpMif:: ==> PNS_NAME_ADD_RESP received" );

                        TUint8 reason( receivedMsg.Get8bit( ISI_HEADER_SIZE +

                            PNS_NAME_ADD_RESP_OFFSET_REASON ) );

                        TInt error( KErrNone );

                        switch ( reason )

                            {

                            case PN_NAME_OK:

                                {

                                LOG(" ==> PN_NAME_OK");

                                OstTrace0( TRACE_NORMAL, DUP5_CDPMIF_RUNL, "CDpMif:: ==> PN_NAME_OK" );

                                error = KErrNone;

                                break;

                                }

                            default:

                                {

                                LOG1(" ==> reason: %d", reason );

                                OstTraceExt1( TRACE_NORMAL, DUP6_CDPMIF_RUNL, "CDpMif:: ==> reason: %hhu", reason );

                                error = KErrGeneral;

                                }

                            }

                            iDataPort.SignalPif( error );

                        break;

                        }

                    case PNS_NAME_REMOVE_RESP:

                        {

                        LOG(" ==> PNS_NAME_REMOVE_RESP received");

                        OstTrace0( TRACE_NORMAL, DUP7_CDPMIF_RUNL, "CDpMif:: ==> PNS_NAME_REMOVE_RESP received" );

                        break;

                        }

                    default:

                        {

                        LOG1(" ==> Unknown message received. ID: %d",

                            message_id );

                        OstTraceExt1( TRACE_NORMAL, DUP8_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id );

                        }

                    }

                break;

                }

            case PN_PIPE:

                {

                switch ( message_id )

                    {

                    case PNS_PEP_CTRL_REQ:

                        {

                        LOG(" ==> PNS_PEP_CTRL_REQ received");

                        OstTrace0( TRACE_NORMAL, DUP9_CDPMIF_RUNL, "CDpMif:: ==> PNS_PEP_CTRL_REQ received" );

                        HandlePepCtrlReq( receivedMsg );

                        break;

                        }

                    case PNS_PEP_STATUS_IND:

                        {

                        LOG(" ==> PNS_PEP_STATUS_IND received");

                        OstTrace0( TRACE_NORMAL, DUP10_CDPMIF_RUNL, "CDpMif:: ==> PNS_PEP_STATUS_IND received" );

                        HandlePepStatusInd( receivedMsg );

                        break;

                        }

                    default:

                        {

                        LOG1(" ==> Unknown message received. ID: %d",

                            message_id );

                        OstTraceExt1( TRACE_NORMAL, DUP11_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id );

                        }

                    }

                break;

                }

            default:

                {

                LOG1(" ==> Unknown message received. ID: %d", message_id );

                OstTraceExt1( TRACE_NORMAL, DUP12_CDPMIF_RUNL, "CDpMif:: ==> Unknown message received. ID: %hhu", message_id );

                }

            }

        iReceiveMessage.Zero();

        // Check if pipe is removed

        if ( PNS_NAME_REMOVE_RESP == message_id &&

            CDpPif::EDpPipeDisconnected == iPifDcs.PipeState() )

            {

            // Check if DataPort is ready to be deleted

            if ( iDataPort.IsReadyToDestruct() )

                {

                iDataPort.DeleteDataPort();

                }

            //no else

            }

        else

            {

            // Renew read

            User::LeaveIfError( Read() );

            }

        }

    }

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

// CDpMif::RunError

// Leave in RunL() is handled here. Error code is returned,

// when internal error has occured.

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

//

TInt CDpMif::RunError(

    TInt aError )

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_RUNERROR, "CDpMif::RunError" );

    LOGM2("CDpMif::RunError - Port %d, error code: %d",

        iDataPort.PortUnit(), aError );

    OstTraceExt2( TRACE_NORMAL, DUP1_CDPMIF_RUNERROR, "CDpMif:: Port: %u, error code: %d", iDataPort.PortUnit(), aError );

    // Message was not necessarily freed, if leave happened.

    iReceiveMessage.Zero();

    return aError;

    }

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

// CDpMif::DoCancel

// This method cancels Isc Api receive.

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

//

void CDpMif::DoCancel()

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_DOCANCEL, "CDpMif::DoCancel" );

    LOGM(" CDpMif::DoCancel");

    iDataPort.ISAHandle().ReceiveCancel();

    }

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

// CDpMif::Read

// Makes a receive request to ISAHandle

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

//

TInt CDpMif::Read()

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_READ, "CDpMif::Read" );

    OstTrace1( TRACE_NORMAL, DUP1_CDPMIF_READ, "CDpMif:: Port: %u", iDataPort.PortUnit() );

    LOGM1("CDpMif::Read - Port %d", iDataPort.PortUnit() );

    TInt ret( KErrNone );

    // length of a message ptr indicates we are already reading

    if ( iReceiveMessage.Length() || IsActive() )

        {

        LOG(" CDpMif::Read, Fail - already reading");

        OstTrace0( TRACE_NORMAL, DUP2_CDPMIF_READ, "CDpMif:: Fail - already reading" );

        ret = KErrGeneral;

        }

    else

        {

        // IscApi receive

        iDataPort.ISAHandle().Receive(

            iStatus, iReceiveMessage, iLen );

        SetActive();

         }

    return ret;

    }

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

// CDpMif::HandlePepCtrlReq

// Handles PepCtrlReq messages

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

//

void CDpMif::HandlePepCtrlReq(

    TIsiReceiveC& aIsiMessage )

    {

    OstTrace0( TRACE_NORMAL, CDPMIF_HANDLEPEPCTRLREQ, "CDpMif::HandlePepCtrlReq" );

    LOGM(" CDpMif::HandlePepCtrlReq");

    // Transaction id

    TUint8 transactionId( aIsiMessage.Get8bit(

        ISI_HEADER_OFFSET_TRANSID ) );

    // Pipe Handle

    if ( PN_PIPE_INVALID_HANDLE == iPifDcs.PipeHandle() )

        {

        TUint8 pipeHandle( aIsiMessage.Get8bit(

            ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PIPEHANDLE) );

        iPifDcs.SetPipeHandle( pipeHandle );

        }

    // PEP Type

    TUint8 pepType( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPTYPE ) );

    // PEP Control ID

    TUint8 ctrlId( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLID ) );

    // PEP Control Data

    TPtrC8 ctrlData;

    // Check if there is data (there is no data for all control id's)

    if ( ( ISI_HEADER_SIZE + SIZE_PNS_PEP_CTRL_REQ ) <=

         aIsiMessage.GetBuffer().Length() )

        {

        // Control Data length is 1 byte

        TInt ctrlDataLen( 1 );

        ctrlData.Set( aIsiMessage.GetData(

            ISI_HEADER_SIZE + PNS_PEP_CTRL_REQ_OFFSET_PEPCTRLDATA,

            ctrlDataLen ) );

        }

    // Get sender device

    TUint8 senderDevice( aIsiMessage.Get8bit(

        ISI_HEADER_OFFSET_SENDERDEVICE ) );

    // Get sender object

    TUint8 senderObject( aIsiMessage.Get8bit(

        ISI_HEADER_OFFSET_SENDEROBJECT ) );

    // E32 return value

    TInt return_E32( KErrNone );

    // PN_PIPE return value

    TInt ret( KErrNone );

    switch ( pepType )

        {

        case PN_PEP_TYPE_COMM:

        case PN_PEP_TYPE_BT_ACC:

            {

            // comm_pep handles ctrl_req

            // Something can go wrong in here. Leaving is not the best case in here.

            // We can send an response message with error value to NOS side and

            // hope for the best.

            return_E32 = iCommPep.HandlePepCtrlReq( ctrlId, ctrlData );

            break;

            }

        default: // Not supported pepType

            {

            LOG1("  ERROR - Unsupported pep type: %d", pepType );

            OstTraceExt1( TRACE_NORMAL, DUP1_CDPMIF_HANDLEPEPCTRLREQ, "CDpMif:: ERROR - Unsupported pep type: %hhu", pepType );

            return_E32 = KErrArgument;

            break;

            }

        }

    // do mapping from E32 error codes => PN_PIPE error codes

    switch ( return_E32 )

        {

        case KErrNone:

            {

            ret = PN_PIPE_NO_ERROR;

            break;

            }

        case KErrNotSupported:

            {

            // this error code should NOT be used according to specification