/*

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

*

*/

#include <phonetisi.h>                  // For ISI_HEADER_SIZE

#include <pn_const.h>                   // For PN_HEADER_SIZE

#include <pipeisi.h>                    // For PNS_PIPE_DATA_OFFSET_DATA

#include <commisi.h>                    // For SIZE_COMMON_MESSAGE_COMM_ISA_ENTITY_NOT_REACHABLE_RESP

#include "router.h"

#include "iadtrace.h"                   // For C_TRACE..

#include "isaaccessextension.h"         // For DIsaAccessExtension

#include "queue.h"                      // For DQueue

#include "iadinternaldefinitions.h"     // For EIADAsync...

#include "iadhelpers.h"                 // For GET_RECEIVER

#include <nsisi.h>                      // For PN_NAMESERVICE...

#include "pipehandler.h"                // For PipeHandler

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "routerTraces.h"

#endif

//#define MODEM_MCE_DOES_NOT_WORK_AS_IT_SHOULD // TODO: to be removed when Bridge Modem SW is ok

// ISCE

#include "memapi.h"                     // For MemApi

#include "trxdefs.h"                    // For ETrx...

// ISCE

// CONSTS

DRouter* DRouter::iThisPtr = NULL;

const TUint32 KCommunicationManagerUID( 0x2002B3D0 );

const TUint32 KNameServiceUID( 0x2002A5A1 );

// TODO: change this to use UnuqueID instead and to extension..

void DRouter::CheckDfc()

{

    OstTrace0( TRACE_NORMAL, DROUTER_CHECKDFC_ENTRY, ">DRouter::CheckDfc" );

    DObject* tempObj = reinterpret_cast<DObject*>( &Kern::CurrentThread() );

    TUint8* buffer = ( TUint8* )Kern::Alloc( 100 );

    TPtr8* bufferPtr = new ( TPtr8 )( buffer, 100 );

    tempObj->Name( *bufferPtr );

    C_TRACE( ( _T( "DRouter::CheckDfc" ) ) );

    if ( bufferPtr->Compare( KIADExtensionDfc ) != KErrNone ) 

        {

        for( TInt i( 0 );i < bufferPtr->Length(); ++i )

           {

           Kern::Printf( "%c", i, bufferPtr->Ptr()[ i ]);

           }

        ASSERT_RESET_ALWAYS( 0, EIADWrongDFCQueueUsed | EIADFaultIdentifier2 << KFaultIdentifierShift  );

        }

    Kern::Free( buffer );

    delete bufferPtr;

    bufferPtr = NULL;

    OstTrace0( TRACE_NORMAL, DROUTER_CHECKDFC_EXIT, "<DRouter::CheckDfc" );

}

#ifdef _DEBUG

#define    ASSERT_DFCTHREAD_INEXT() CheckDfc()

#else

#define    ASSERT_DFCTHREAD_INEXT()

#endif

DRouter::DRouter():

    iConnectionStatus( EIADConnectionNotOk )

    , iBootDone( EFalse )

    {

    OstTrace0( TRACE_NORMAL, DROUTER_DROUTER_ENTRY, "<DRouter::DRouter" );

    C_TRACE( ( _T( "DRouter::DRouter ->" ) ) );

    // owned

#ifdef NCP_COMMON_BRIDGE_FAMILY_PIPE_SUPPORT

    iPipeHandler = new DPipeHandler( *this );

#endif

    iCommonRxQueue = new DQueue( KIADExtensionRxQueueSize );

    // Initialize channels to NULL when channel is opened !NULL.

    for( TInt i( 0 ); i < EIADSizeOfChannels; ++i )

        {

        iChannelTable[ i ].iChannel = NULL;

        iChannelTable[ i ].iWaitingChannel = NULL;

        iChannelTable[ i ].iType = ENormalOpen;

        }

    iCommonRxDfc = new TDfc( CommonRxDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtCommonRxPriori );

    // not owned, just using.

    // Set null when not registered.

    iInitCmtDfc = new TDfc( InitCmtDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtInitCmtPriori );

    iConnStatDfc = new TDfc( NotifyObjLayerConnStatDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADExtConnStatPriori );

    ASSERT_RESET_ALWAYS( iCommonRxDfc && iInitCmtDfc && iConnStatDfc, EIADMemoryAllocationFailure | EIADFaultIdentifier18 << KFaultIdentifierShift );

    iMaxFrameSize = 0x0000;

    // ISCE

    iLinksArray = new MISIRouterLinkIf*[ DRouter::EISIAmountOfMedias ];

    // TODO: fault codes and ids

    ASSERT_RESET_ALWAYS( iLinksArray, ( EIADMemoryAllocationFailure | EIADFaultIdentifier17 << KFaultIdentifierShift ) );

    // Initialize links

    for( TInt i( 0 ); i < DRouter::EISIAmountOfMedias; i++ )

        {

        iLinksArray[ i ] = NULL;

        C_TRACE( ( _T( "DRouter::DRouter %d" ), i ) );

        }

    // Configuration of ISI links. TODO: devices and link configurations for coming platforms are unknown and to be done later.

    iLinksArray[ DRouter::EISIMediaHostSSI ] = MISIRouterLinkIf::CreateLinkF( this, PN_MEDIA_MODEM_HOST_IF, ETrxSharedMemory );

    DRouter::iThisPtr = this;

    C_TRACE( ( _T( "DRouter::DRouter 0x%x <-" ), this ) );

    OstTrace1( TRACE_NORMAL, DROUTER_DROUTER_EXIT, "<DRouter::DRouter;this=%x", this );

    }

DRouter::~DRouter(

        // None

       )

    {

    OstTrace0( TRACE_NORMAL, DUP1_DROUTER_DROUTER_ENTRY, "<DRouter::~DRouter" );

//ISCE

    // owning so deleting

    for( TInt i( 0 ); i < EISIAmountOfMedias; i++ )

        {

        MISIRouterLinkIf* temp = iLinksArray[ i ];

        temp->Release();

        temp = NULL;

        iLinksArray[ i ] = NULL;

        }

//ISCE

    C_TRACE( ( _T( "DRouter::~DRouter 0x%x ->" ), this ) );

    // Initialize channels to NULL when channel is opened !NULL.

    for( TInt i( 0 ); i < EIADSizeOfChannels; ++i )

        {

        iChannelTable[ i ].iChannel = NULL;

        iChannelTable[ i ].iWaitingChannel = NULL;

        iChannelTable[ i ].iType = ENormalOpen;

        }

#ifdef NCP_COMMON_BRIDGE_FAMILY_PIPE_SUPPORT

    if( iPipeHandler )

        {

        delete iPipeHandler;

        iPipeHandler = NULL;

        }

#endif

    if( iCommonRxQueue )

        {

        delete iCommonRxQueue;

        iCommonRxQueue = NULL;

        }

    if( iCommonRxDfc )

        {

        iCommonRxDfc->Cancel();

        delete iCommonRxDfc;

        iCommonRxDfc = NULL;

        }

    if( iInitCmtDfc )

        {

        delete iInitCmtDfc;

        iInitCmtDfc = NULL;

        }

    if( iConnStatDfc )

        {

        delete iConnStatDfc;

        iConnStatDfc = NULL;

        }

    C_TRACE( ( _T( "DRouter::~DRouter 0x%x <-" ), this ) );

    OstTrace1( TRACE_NORMAL, DUP1_DROUTER_DROUTER_EXIT, "<DRouter::~DRouter;this=%x", this );

    }

// From   start

// Do not call from ISR context!! Can only be called from Extension DFCThread context.

EXPORT_C TDes8& DRouter::AllocateBlock(

        const TUint16 aSize

        )

    {

    OstTraceExt1( TRACE_NORMAL, DROUTER_ALLOCATEBLOCK_ENTRY, "<>DRouter::AllocateBlock;aSize=%hu", aSize );

    C_TRACE( ( _T( "DRouter::AllocateBlock %d <->" ), aSize ) );

    ASSERT_CONTEXT_ALWAYS( NKern::EThread, 0 );

    ASSERT_DFCTHREAD_INEXT();

    ASSERT_RESET_ALWAYS( aSize, EIADWrongParameter | EIADFaultIdentifier9 << KFaultIdentifierShift );

// ISCE

//    ASSERT_RESET_ALWAYS( iIST, EIADNullParameter | EIADFaultIdentifier17 << KFaultIdentifierShift  );

//    return iIST->AllocateBlock( aSize );// TODO: Print ptr!!!

    return MemApi::AllocBlock( aSize );

// ISCE

    }

EXPORT_C TDes8& DRouter::AllocateDataBlock(

        const TUint16 aSize

        )

    {

    OstTraceExt1( TRACE_NORMAL, DROUTER_ALLOCATEDATABLOCK_ENTRY, ">DRouter::AllocateDataBlock;aSize=%hu", aSize );

    C_TRACE( ( _T( "DRouter::AllocateDataBlock %d <->" ), aSize ) );

    TUint32 neededLength( aSize + ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_DATA );

    TDes8& tmp = this->AllocateBlock( neededLength );

#ifdef NCP_COMMON_BRIDGE_FAMILY_PIPE_SUPPORT

    tmp.SetLength( neededLength );

    TUint8* msgPtr = const_cast<TUint8*>( tmp.Ptr() );

    SET_RECEIVER_DEV( msgPtr, PN_DEV_DONT_CARE );    

    ASSERT_RESET_ALWAYS( neededLength > ISI_HEADER_OFFSET_MESSAGEID, EIADOverTheLimits | EIADFaultIdentifier1 << KFaultIdentifierShift  );

    msgPtr[ ISI_HEADER_OFFSET_RESOURCEID ] = PN_PIPE;

    msgPtr[ ISI_HEADER_OFFSET_MESSAGEID ] = PNS_PIPE_DATA;

    SET_RECEIVER_OBJ( msgPtr, PN_OBJ_ROUTER );

    SET_LENGTH( tmp, ( tmp.Length() - PN_HEADER_SIZE ) );

#endif

    OstTrace1( TRACE_NORMAL, DROUTER_ALLOCATEDATABLOCK_EXIT, "<DRouter::AllocateDataBlock;tmp=%x",( TUint )&( tmp ) );    

    return tmp;

    }

EXPORT_C void DRouter::Close(

        const TUint16 aChannelId

        )

    {

    OstTraceExt1( TRACE_NORMAL, DROUTER_CLOSE_ENTRY, ">DRouter::Close;aChannelId=%hx", aChannelId );

    C_TRACE( ( _T( "DRouter::Close 0x%x ->" ), aChannelId ) );

    // Channel must be from appropiate length and although it is sixteenbit value it must contain only 8-bit values. If over 8-bit changes needed.

    ASSERT_RESET_ALWAYS( aChannelId < EIADSizeOfChannels || aChannelId < 0xff, EIADWrongParameter | EIADFaultIdentifier10 << KFaultIdentifierShift | aChannelId << KChannelNumberShift );

    ASSERT_DFCTHREAD_INEXT();

    // If channel open (!NULL) set as closed (NULL) or if channel open is pending.

    ASSERT_RESET_ALWAYS( aChannelId < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannelId << KChannelNumberShift | EIADFaultIdentifier21 << KFaultIdentifierShift );

    if( iChannelTable[ aChannelId ].iChannel || iChannelTable[ aChannelId ].iWaitingChannel )

        {

        C_TRACE( ( _T( "DRouter::Close open->close 0x%x" ), aChannelId ) );

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

        if( iChannelTable[ aChannelId ].iType != ELoan )

            {

#endif

            iChannelTable[ aChannelId ].iChannel = NULL;

            iChannelTable[ aChannelId ].iWaitingChannel = NULL;

            iChannelTable[ aChannelId ].iType = ENormalOpen;

            const TInt indicationCancelOrderSize( 2 );

            TDes8& cancelOrder = AllocateBlock( indicationCancelOrderSize );

            cancelOrder.Append( 0x00 );

            cancelOrder.Append( 0x00 );

            // Order internally, so no return values above ::Close { 0x00, 0x00 } 8-bit cancel indication.

            TInt error( OrderIndication( cancelOrder, aChannelId, EFalse ) );

            C_TRACE( ( _T( "DRouter::Close open->close indication order returned %d 0x%x" ), error, aChannelId ) );

            OstTraceExt2( TRACE_NORMAL, DROUTER_CLOSE, "DRouter::Close open->close indication order returned;error=%d;aChannelId=%x", error, aChannelId );

            ASSERT_RESET_ALWAYS( KErrNone == error, EIADIndicationOrderFailed | static_cast<TUint8>( ( aChannelId << KChannelNumberShift ) ) );

            DeAllocateBlock( cancelOrder );

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

            }

        else

            {

            C_TRACE( ( _T( "DRouter::Close open->close loaned channel 0x%x" ), aChannelId ) );

            OstTrace1( TRACE_NORMAL, DROUTER_CLOSE_2, "DRouter::Close open->close loaned channel;aChannelId=%x", aChannelId );

            iChannelTable[ aChannelId ].iType = ENormalOpen;

            iChannelTable[ aChannelId ].iChannel = iChannelTable[ aChannelId ].iWaitingChannel;

            iChannelTable[ aChannelId ].iWaitingChannel = NULL;

            }

#endif

        }

    C_TRACE( ( _T( "DRouter::Close 0x%x <-" ), aChannelId ) );

    OstTrace0( TRACE_NORMAL, DROUTER_CLOSE_EXIT, "<DRouter::Close" );

    }

// Do not call from ISR context!! Can only be called from Extension DFCThread context.

EXPORT_C void DRouter::DeAllocateBlock(

        TDes8& aBlock

        )

    {

    OstTrace1( TRACE_NORMAL, DROUTER_DEALLOCATEBLOCK_ENTRY, ">DRouter::DeAllocateBlock;aBlock=%x", ( TUint )&( aBlock ) );

    C_TRACE( ( _T( "DRouter::DeAllocateBlock 0x%x ->" ), &aBlock ) );

    ASSERT_CONTEXT_ALWAYS( NKern::EThread, 0 );

    ASSERT_DFCTHREAD_INEXT();

// ISCE

//    ASSERT_RESET_ALWAYS( iIST, EIADNullParameter | EIADFaultIdentifier18 << KFaultIdentifierShift  );

//    iIST->DeallocateBlock( aBlock );

    MemApi::DeallocBlock( aBlock );

// ISCE

    C_TRACE( ( _T( "DRouter::DeAllocateBlock 0x%x <-" ), &aBlock ) );

    OstTrace0( TRACE_NORMAL, DROUTER_DEALLOCATEBLOCK_EXIT, "<DRouter::DeAllocateBlock" );    

    }

EXPORT_C TInt DRouter::GetConnectionStatus(

            // None

            )

    {

    OstTrace0( TRACE_NORMAL, DROUTER_GETCONNECTIONSTATUS_ENTRY, "<DRouter::GetConnectionStatus" );

    C_TRACE( ( _T( "DRouter::GetConnectionStatus %d <->" ), iConnectionStatus ) );

    ASSERT_DFCTHREAD_INEXT();

    OstTrace1( TRACE_NORMAL, DROUTER_GETCONNECTIONSTATUS, "<DRouter::GetConnectionStatus;iConnectionStatus=%x", iConnectionStatus );    

    return iConnectionStatus;

    }

EXPORT_C TInt DRouter::GetFlowControlStatus()

{

    OstTrace0( TRACE_NORMAL, DROUTER_GETFLOWCONTROLSTATUS_ENTRY, "<>DRouter::GetFlowControlStatus" );

    ASSERT_DFCTHREAD_INEXT();

    return KErrNotSupported; // TODO

}

EXPORT_C TInt DRouter::GetMaxDataSize(

        // None

        )

    {

    OstTrace0( TRACE_NORMAL, DROUTER_GETMAXDATASIZE_ENTRY, ">DRouter::GetMaxDataSize" );

    C_TRACE( ( _T( "DRouter::GetMaxDataSize ->" ) ) );

    ASSERT_DFCTHREAD_INEXT();

    TInt excludeSize( iMaxFrameSize - ( ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_DATA ) );

    // Set the data to be divisible by four.

    TInt allowedCount( excludeSize - ( excludeSize % 4 ) );

    C_TRACE( ( _T( "DRouter::GetMaxDataSize %d <-" ), allowedCount ) );

    OstTrace1( TRACE_NORMAL, DROUTER_GETMAXDATASIZE_EXIT, "<DRouter::GetMaxDataSize;allowedCount=%d", allowedCount );

    return allowedCount;

    }

// KErrNone, channelid with channel object open ok

// KErrNotSupported, resource not supported or in use causes name_add_req to fail

// KErrInUse, channelid opened by same channel object earlier

// KErrAlreadyExists, channel opened by some other channel object earlier

// In completechannelreq, set ~channel number  as ~~channelnumber only if KErrNone or KErrInUse

EXPORT_C void DRouter::Open(

        const TUint16 aChannel,

        const TUint16 aRequest,

        MIAD2ChannelApi* aCallback

        )

    {

    OstTraceExt3( TRACE_NORMAL, DROUTER_OPEN_ENTRY, ">DRouter::Open;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) );

    C_TRACE( ( _T( "DRouter::Open 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) );

    ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift  );

    ASSERT_DFCTHREAD_INEXT();

    ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | (TUint8)aChannel << KChannelNumberShift | EIADFaultIdentifier26 << KFaultIdentifierShift );

    if( iConnectionStatus == EIADConnectionOk )

        {

        // If not null channel is allready open.

        if( iChannelTable[ aChannel ].iChannel || 

            iChannelTable[ aChannel ].iWaitingChannel )

            {

            // If another channel tries to open already open channel.

            TRACE_WARNING( iChannelTable[ aChannel ].iChannel == aCallback, (TUint8)aChannel << KChannelNumberShift );

            // If same object calling KErrInUser if other but same channel KErrAlreadyExists

            aCallback->CompleteChannelRequest( aRequest, ( iChannelTable[ aChannel ].iChannel == aCallback ? KErrInUse : KErrAlreadyExists ) );

            }

        // Null so channel is not open, set !null to mark opened channel.

        else

            {

            C_TRACE( ( _T( "DRouter::Open channel 0x%x normal 0x%x" ), aChannel, aCallback ) );

            OstTraceExt1( TRACE_NORMAL, DUP1_DROUTER_OPEN, "DRouter::Open normal;aChannel=%hx", aChannel );

            iChannelTable[ aChannel ].iChannel = aCallback;

            aCallback->CompleteChannelRequest( aRequest, KErrNone );

            }

        }

    else

        {

        C_TRACE( ( _T( "DRouter::Open not ready" ) ) );

        OstTrace0( TRACE_NORMAL, DUP2_DROUTER_OPEN, "DRouter::Open Not ready" );        

        ASSERT_RESET_ALWAYS( !iChannelTable[ aChannel ].iWaitingChannel, EIADWrongRequest | EIADFaultIdentifier15 << KFaultIdentifierShift  );

        iChannelTable[ aChannel ].iWaitingChannel = aCallback;

        iChannelTable[ aChannel ].iType = ( ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ? ENormalOpen : ENormalOpen );//??? TODO FIX THIS

        }

    C_TRACE( ( _T( "DRouter::Open 0x%x <-" ), aChannel ) );

    OstTraceExt1( TRACE_NORMAL, DROUTER_OPEN_EXIT, "<DRouter::Open;aChannel=%hx", aChannel );

    }

// With resource and media

EXPORT_C void DRouter::Open(

        const TUint16 aChannel,

        const TUint16 aRequest,

        const TDesC8& aOpenInfo,

        MIAD2ChannelApi* aCallback

        )

    {

    OstTraceExt4( TRACE_NORMAL, DUP1_DROUTER_OPEN_ENTRY, ">DRouter::Open;aChannel=%hx;aRequest=%hu;aOpenInfo=%x;aCallback=%x", aChannel, aRequest, ( TUint )&( aOpenInfo ), ( TUint )( aCallback ) );

    C_TRACE( ( _T( "DRouter::Open 0x%x %d 0x%x 0x%x ->" ), aChannel, aRequest, &aOpenInfo, aCallback ) );

    // Some maniac from modem sw decided to remove name service in the last meters, hip-hip hurray inform which clients use resource from open to help debug!

    TRACE_ASSERT_INFO( 0, (TUint8)aChannel<<KChannelNumberShift );

    // Treat as normal open to enable the sending.

    // NOTE! SUPPORT FOR RESOURCE OPEN DOES NOT EXISTS: CLIENT SHOULD NAME SERVICE BY ISI IF. SUPPORT FOR NAME SERVICE DOES NOT EXIST IN APE SW YET: NCP_COMMON_BRIDGE_FAMILY_NAME_SERVICE_SUPPORT

    Open( aChannel, aRequest, aCallback );

    C_TRACE( ( _T( "DRouter::Open 0x%x <-" ), aChannel ) );

    OstTraceExt1( TRACE_NORMAL, DUP1_DROUTER_OPEN_EXIT, "<DRouter::Open;aChannel=%hx", aChannel );

    }

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

EXPORT_C TInt DRouter::Loan(

        const TUint16 aChannel,

        const TUint16 aRequest,

        MIAD2ChannelApi* aCallback

        )

    {

    C_TRACE( ( _T( "DRouter::Loan 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) );

    OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_LOAN_ENTRY, ">DRouter::Loan;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) );

    ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift  );// TODO

    ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | EIADFaultIdentifier11 << KFaultIdentifierShift );// TODO

    ASSERT_DFCTHREAD_INEXT();

    ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, aChannel );

    TInt error( KErrNone );

#ifdef NCP_COMMON_BRIDGE_FAMILY_PIPE_SUPPORT

    // Is connection lost.

    error = ( iConnectionStatus == EIADConnectionNotOk ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is loaning a resticted channel.

    error = ( KErrNone == error && ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is loaning it self?

    error = ( KErrNone == error && ( iChannelTable[ aChannel ].iChannel == aCallback ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is loaning currently not open channel.

    error = ( KErrNone == error && ( !iChannelTable[ aChannel ].iChannel ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is loaning already loaned channel.

    error = ( KErrNone == error && ( iChannelTable[ aChannel ].iType == ELoan ) ) ? KErrAlreadyExists : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    if( KErrNone == error )

        {

        // Who is loaning whose channel.

        C_TRACE( ( _T( "DRouter::Loan loaning ch 0x%x from chObj 0x%x to chObj 0x%x setting previous as waiting" ), aChannel, iChannelTable[ aChannel ].iChannel, aCallback ) );

        OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_LOAN, "DRouter::Loan loaning;aChannel=%hx;channelPtr=%hx;callbackPtr=%hx", aChannel, (TUint)iChannelTable[ aChannel ].iChannel, (TUint)aCallback );

        iChannelTable[ aChannel ].iWaitingChannel = iChannelTable[ aChannel ].iChannel;// TEST WITH WAITING CHANNEL FIRST

        iChannelTable[ aChannel ].iType = ELoan;

        iChannelTable[ aChannel ].iChannel = aCallback;

        iPipeHandler->PipeLoaned( aChannel, aCallback );

        }

#endif

    C_TRACE( ( _T( "DRouter::Loan 0x%x %d<-" ), aChannel, error ) );

    OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_LOAN_EXIT, "<DRouter::Loan;aChannel=%hx;error=%d", aChannel, error );

    return error;

    }

EXPORT_C TInt DRouter::ReturnLoan(

        const TUint16 aChannel,

        const TUint16 aRequest,

        MIAD2ChannelApi* aCallback

        )

    {

    C_TRACE( ( _T( "DRouter::ReturnLoan 0x%x %d 0x%x ->" ), aChannel, aRequest, aCallback ) );

    OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN_ENTRY, ">DRouter::ReturnLoan;aChannel=%hx;aRequest=%hu;aCallback=%x", aChannel, aRequest, ( TUint )( aCallback ) );

    ASSERT_RESET_ALWAYS( aCallback, EIADNullParameter | EIADFaultIdentifier19 << KFaultIdentifierShift  );// TODO

    ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, EIADWrongParameter | EIADFaultIdentifier11 << KFaultIdentifierShift );// TODO

    ASSERT_DFCTHREAD_INEXT();

    ASSERT_RESET_ALWAYS( aChannel < EIADSizeOfChannels, aChannel );

    TInt error( KErrNone );

#ifdef NCP_COMMON_BRIDGE_FAMILY_PIPE_SUPPORT

    // Is connection lost.

    error = ( iConnectionStatus == EIADConnectionNotOk ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is loaning a resticted channel.

    error = ( KErrNone == error && ( aChannel == EIADNokiaDRM || aChannel == EIADNokiaSecurityDriver ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is retuning someone elses loan?

    error = ( KErrNone == error && ( iChannelTable[ aChannel ].iChannel != aCallback ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is returning currently not open channel.

    error = ( KErrNone == error && ( !iChannelTable[ aChannel ].iChannel ) ) ? KErrNotSupported : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    // Is returning a not loaned channel.

    error = ( KErrNone == error && ( iChannelTable[ aChannel ].iType != ELoan ) ) ? KErrAlreadyExists : error;

    TRACE_ASSERT_INFO( KErrNone == error, error );

    if( KErrNone == error )

        {

        // Who is loaning whose channel.

        C_TRACE( ( _T( "DRouter::ReturnLoan returning loan ch 0x%x to chObj 0x%x from chObj 0x%x setting previous as waiting" ), aChannel, iChannelTable[ aChannel ].iWaitingChannel, aCallback ) );

        OstTraceExt3( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN, "DRouter::Loan loaning;aChannel=%hx;waitingchannelPtr=%hx;callbackPtr=%hx", aChannel, (TUint)iChannelTable[ aChannel ].iWaitingChannel, (TUint)aCallback );

        iPipeHandler->PipeLoanReturned( aChannel, iChannelTable[ aChannel ].iWaitingChannel );

        }

#endif

    C_TRACE( ( _T( "DRouter::ReturnLoan 0x%x %d<-" ), aChannel, error ) );

    OstTraceExt2( TRACE_NORMAL, DUP1_DROUTER_RETURNLOAN_EXIT, "<DRouter::ReturnLoan;aChannel=%hx;error=%d", aChannel, error );

    return error;

    }

#endif

EXPORT_C TInt DRouter::OrderIndication(

        TDes8& anOrder,

        const TUint16 aCh,

        const TBool a32Bit

        )

    {

    OstTraceExt3( TRACE_NORMAL, DROUTER_ORDERINDICATION_ENTRY, ">DRouter::OrderIndication;anOrder=%x;aCh=%hx;a32Bit=%d", ( TUint )&( anOrder ), aCh, a32Bit );

    C_TRACE( ( _T( "DRouter::OrderIndication 0x%x 0x%x %d ->" ), &anOrder, aCh, a32Bit ) );

    ASSERT_DFCTHREAD_INEXT();

    TInt orderLength( anOrder.Length() );

    TInt msgOk = ( 0 == orderLength ) ? KErrBadDescriptor : KErrNone;

    TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift );

    // Should be divisible by two if not 32 bit.

    msgOk = ( ( msgOk == KErrNone && ( !a32Bit && 0 != orderLength % 2 ) ) ? KErrBadDescriptor : msgOk );

    TRACE_ASSERT_INFO( msgOk == KErrNone, (TUint8)aCh<<KChannelNumberShift );

    // Should be divisible by five if 32 bit.