/*

* 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 <kern_priv.h>              // For DMutex

#include "p2puserchannel.h"         // For DP2PUserChannel

#include "msgqueue.h"               // For DMsgQueue 

#include "p2proutertrace.h"         // For C_TRACE, ASSERT_RESET.. and fault codes.

#include "memapi.h"                 // MemApi

#include "p2pdefs.h"                // For EP2PAmountOfProtocols

enum TP2PUserChannelFaults

    {

    EP2PUserChannelMemAllocFail = 0x00,

    EP2PUserChannelMemAllocFail1,

    EP2PUserChannelMemAllocFail2,

    EP2PUserChannelWrongRequest,

    EP2PUserChannelWrongRequest1,

    EP2PUserChannelWrongRequest2,

    EP2PUserChannelWrongRequest3,

    EP2PUserChannelWrongRequest4,

    EP2PUserChannelWrongRequest5,

    EP2PUserChannelWrongRequest6,

    EP2PUserChannelWrongRequest7,

    EP2PUserChannelWrongParam,

    EP2PUserChannelWrongParam2,

    EP2PUserChannelProtocolIdNotSpecified,

    EP2PUserChannelOverTheArrayLimits,

    EP2PUserChannelDesWriteFailed,

    EP2PUserChannelSameRequest,

    EP2PUserChannelSameRequest2,

    EP2PUserChannelNullParam,

    EP2PUserChannelNullParam2,

    EP2PUserChannelDesReadFailed,

    EP2PIUserChannelfNotThreadContext,

    EP2PIUserChannelfNotThreadContext2,

    EP2PIUserChannelfNotThreadContext3,

    EP2PIUserChannelfNotThreadContext4,

    EP2PIUserChannelfNotThreadContext5,

    EP2PUserChannelMutexCreateFailed,

    EP2PUserChannelMutexWaitFailed,

    EP2PUserChannelMutexWaitFailed2,

    EP2PUserChannelMutexWaitFailed3,

    EP2PUserChannelMutexWaitFailed4,

    EP2PUserChannelReqQueueOutOfSync,

    EP2PUserChannelReqQueueOutOfSync1,

    EP2PUserChannelReqQueueOutOfSync2,

    EP2PUserChannelReqQueueOutOfSync3,

    EP2PUserChannelReqQueueOutOfSync4,

    EP2PUserChannelReqQueueOutOfSync5,

    EP2PUserChannelReqQueueOutOfSync6,

    EP2PUserChannelReqQueueOutOfSync7,

    EP2PUserChannelReqQueueOverTheLimits,

    EP2PUserChannelReqQueueOverTheLimits2,

    EP2PUserChannelReqQueueWrongRequest,

    EP2PUserChannelReqQueueWrongRequest2,

    EP2PUserChannelReqQueueMemoryAllocFailure,

    EP2PUserChannelReqQueueCommon,

    };

// Extracting and adding the pipeheader.

const TInt KFirstParam( 0 );

const TInt KSecondParam( 1 );

const TInt KNoParams( KErrNone );

const TInt KOneParam( 1 );

const TInt KTwoParams( 2 );

const TInt KThreeParams( 3 );

const TInt KDestStartOffset( 0 );

const TInt KP2PLddEmptyRxPriori( 1 );

const TInt KP2PLddCompletePriori( 1 );

const TInt KP2PMaximumSendSize( 0xffff );

//DMutex* DP2PUserChannel::iShP2PProtocolIdMutex = NULL;

_LIT8( KP2PUserChannelP2PProtocolIdMutex, "P2PUserChannelP2PProtocolIdMutex" );

//

// user<> kernel interaction() done in LDD DFC thread

// 

// kernel<>kernel interaction() done in Extension DFC thread

//

// DEMAND_PAGING

// Receive (write k>u) is done only in LDD thread context to allow Extension thread to continue when dp swaps.

// Send ((write u>k) is not done at the moment in LDD thread context only. Check is it possible to happend (not to be in usable memory after send (unlikely?)).

DP2PUserChannel::DP2PUserChannel(

        // None

        )

    :

    iShP2PProtocolId( EP2PAmountOfProtocols ),

    iReceiveBufPtr( NULL ),

    iRx( NULL ),

    iP2PReqQueue( NULL ),

    iThread( &Kern::CurrentThread() )

    {

    C_TRACE( ( _T( "DP2PUserChannel::DP2PUserChannel>" ) ) );

    iRouterIf = MP2PChRouterIf::GetIf();

    ASSERT_RESET_ALWAYS( iRouterIf, ( EP2PUserChannelMemAllocFail | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    iEmptyRxQueueDfc = new TDfc( EmptyRxQueueDfc, this, iRouterIf->GetDfcThread( MP2PChRouterIf::EP2PLddDfcThread ), KP2PLddEmptyRxPriori );

    iCompleteChannelRequestDfc = new TDfc( CompleteChReqDfc, this, iRouterIf->GetDfcThread( MP2PChRouterIf::EP2PLddDfcThread ), KP2PLddCompletePriori );

    iP2PReqQueue = new DP2PReqQueue();

    ASSERT_RESET_ALWAYS( iEmptyRxQueueDfc && iCompleteChannelRequestDfc && iP2PReqQueue, ( EP2PUserChannelMemAllocFail1 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    TInt err( Kern::MutexCreate( iShP2PProtocolIdMutex, KP2PUserChannelP2PProtocolIdMutex, KMutexOrdGeneral0 ) );

    ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EP2PUserChannelMutexCreateFailed | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    C_TRACE( ( _T( "DP2PUserChannel::DP2PUserChannel<" ) ) );

    }

DP2PUserChannel::~DP2PUserChannel(

        // None

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x>" ), this, iShP2PProtocolId ) );

    // owned starts

    if( iEmptyRxQueueDfc )

        {

        C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iEmptyRxQueueDfc 0x%x" ), this, iShP2PProtocolId, iEmptyRxQueueDfc ) );

        iEmptyRxQueueDfc->Cancel();

        delete iEmptyRxQueueDfc;

        iEmptyRxQueueDfc = NULL;

        }

    if( iCompleteChannelRequestDfc )

        {

        C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iCompleteChannelRequestDfc 0x%x" ), this, iShP2PProtocolId, iCompleteChannelRequestDfc ) );

        iCompleteChannelRequestDfc->Cancel();

        delete iCompleteChannelRequestDfc;

        iCompleteChannelRequestDfc = NULL;

        }

    if( iRx )

        {

        C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iRx 0x%x" ), this, iShP2PProtocolId, iRx ) );

        delete iRx;

        iRx = NULL;

        }

    if( iReceiveBufPtr )

        {

        C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iReceiveBufPtr 0x%x" ), this, iShP2PProtocolId, iReceiveBufPtr ) );

        iReceiveBufPtr = NULL;

        }

    if( iP2PReqQueue )

       {

       C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iP2PReqQueue 0x%x" ), this, iShP2PProtocolId, iP2PReqQueue ) );

       delete iP2PReqQueue;

       iP2PReqQueue = NULL;

       }

    // No need to check, if failed reseted already

    C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x iShP2PProtocolIdMutex 0x%x" ), this, iShP2PProtocolId, iShP2PProtocolIdMutex ) );

    iShP2PProtocolIdMutex->Close( NULL );

    // owned ends

    iRouterIf = NULL;

    Kern::SafeClose( reinterpret_cast<DObject*&>(iThread), NULL );

    C_TRACE( ( _T( "DP2PUserChannel::~DP2PUserChannel 0x%x 0x%x<" ), this, iShP2PProtocolId ) );

    }

/*

* Executed in user thread context thread inside CS, cannot be pre-empted.

* Channel can not be used before creation, so no need to synch if congesting only btw the creating user thread and one thread.

*/    

TInt DP2PUserChannel::DoCreate(

        TInt, //aUnit,              // No need to use this, we can avoid the limit of 32 channels

        const TDesC8* anInfo,       // Contains the protocolId

        const TVersion& // aVer     // Not used at the moment.

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::DoCreate 0x%x 0x%x 0x%x>" ), this, iShP2PProtocolId, anInfo ) );

    if( !Kern::CurrentThreadHasCapability( ECapabilityCommDD, __PLATSEC_DIAGNOSTIC_STRING( "Check by: P2PRouter" ) ) ) return KErrPermissionDenied;  

    TRACE_ASSERT_INFO( anInfo, EP2PUserChannelProtocolIdNotSpecified );

    // Check for channel number inside anInfo.

    TRACE_ASSERT_INFO( anInfo->Length() > 0, ( EP2PUserChannelOverTheArrayLimits | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    if( !anInfo || anInfo->Length() == 0 ) return KErrNotSupported;

    TUint8 protocolId = static_cast<TUint8>( ( *anInfo )[ 0 ] );

    TRACE_ASSERT_INFO( ( protocolId < EP2PAmountOfProtocols ), ( EP2PUserChannelWrongParam | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    if( protocolId >= EP2PAmountOfProtocols ) return KErrNotSupported;

    TInt err( Kern::MutexWait( *iShP2PProtocolIdMutex ) );

    ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EP2PUserChannelMutexWaitFailed | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    // If channel is already used for some protocol.

    if( iShP2PProtocolId != EP2PAmountOfProtocols )

        {

        Kern::MutexSignal( *iShP2PProtocolIdMutex );

        return KErrAlreadyExists;

        }

    iShP2PProtocolId = ~protocolId;

    Kern::MutexSignal( *iShP2PProtocolIdMutex );

    C_TRACE( ( _T( "DP2PUserChannel::DoCreate protocolId 0x%x 0x%x" ), this, iShP2PProtocolId ) );

    iRx = new DMsgQueue( KP2PLddRxQueuSize );

    ASSERT_RESET_ALWAYS( iRx, ( EP2PUserChannelMemAllocFail2 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    // Other DFC functions handling user<>kernel copying done in ldd DFC. Ldd DFC function priority is 1.

    SetDfcQ( iRouterIf->GetDfcThread( MP2PChRouterIf::EP2PDfcThread ) );

    iMsgQ.Receive();

    DObject* thread = reinterpret_cast<DObject*>( iThread );

    // Open is needed to increase ref count to calling thread that is decreased in Kern::SafeClose

    // Possible returns KErrNone ? KErrGeneral

    TInt threadOpen( thread->Open() );

    TRACE_ASSERT_INFO( threadOpen == KErrNone, (TUint8)iShP2PProtocolId );

    C_TRACE( ( _T( "DP2PUserChannel::DoCreate 0x%x 0x%x %d<" ), this, iShP2PProtocolId, threadOpen ) );

    return threadOpen;

    }

void DP2PUserChannel::HandleMsg(

        TMessageBase* aMsg

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::HandleMsg 0x%x 0x%x 0x%x>" ), this, iShP2PProtocolId, aMsg ) );

    TThreadMessage& m= *( static_cast< TThreadMessage* >( aMsg ) );

    TInt id( m.iValue );

    if( static_cast<TInt>( ECloseMsg ) == id )

        {

        C_TRACE( ( _T( "DP2PUserChannel::HandleMsg ECloseMsg 0x%x 0x%x 0x%x" ), this, iShP2PProtocolId, aMsg ) );

        m.Complete( HandleSyncRequest( EP2PClose, NULL ), EFalse );

        }

    else if( KMaxTInt == id )

        {

        C_TRACE( ( _T( "DP2PUserChannel::HandleMsg cancel 0x%x 0x%x 0x%x" ), this, iShP2PProtocolId, aMsg ) );

        DoCancel( id, m.Int0() );

        m.Complete( KErrNone, ETrue );

        }

    else

        {

        ASSERT_RESET_ALWAYS( ( KErrNotFound < id ), ( EP2PUserChannelWrongRequest | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

        C_TRACE( ( _T( "DP2PUserChannel::HandleMsg request 0x%x 0x%x %d 0x%x" ), this, iShP2PProtocolId, id, aMsg ) );

        TInt completeValue( KErrNone );

        TInt ulen( KErrNotFound );

        switch ( id )

            {

            case EP2PClose:

                {

                ulen = KNoParams;

                break;

                }

            case EP2PSend:

            case EP2PAsyncConnectionLost:

                {

                ulen = KOneParam;

                break;

                }

            case EP2PAsyncOpen:

            case EP2PAsyncReceive:

                {

                ulen = KTwoParams;

                break;

                }

            default:

                {

                ASSERT_RESET_ALWAYS( 0, ( EP2PUserChannelWrongRequest1 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

                break;

                }

            }

        TUint32* table[ KThreeParams ];

        completeValue = Kern::ThreadRawRead( iThread, m.Ptr0(), table, ulen * sizeof( TAny* ) );

        if( completeValue == KErrNone )

            {

            switch( id )

                {

                // All asynchronous requests.

                case EP2PAsyncOpen:

                case EP2PAsyncReceive:

                case EP2PAsyncConnectionLost:

                    {

                    // No need to check return value in async functions, completed to user

                    HandleAsyncRequest( id, table );

                    break;

                    }

                case EP2PClose:

                case EP2PSend:

                    {

                    completeValue = HandleSyncRequest( id, table );

                    break;

                    }

                default:

                    {

                    ASSERT_RESET_ALWAYS( 0, ( EP2PUserChannelWrongRequest2 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

                    break;

                    }

                }

            }

        m.Complete( completeValue, ETrue );

        }

    C_TRACE( ( _T( "DP2PUserChannel::HandleMsg 0x%x 0x%x 0x%x<" ), this, iShP2PProtocolId, aMsg ) );

    }

TInt DP2PUserChannel::Request(

        TInt aReqNo,

        TAny* a1,

        TAny* //a2

        )

    {

    // Programmer errors.

    TInt result( KErrNotFound );

    // All request go in kernel context and with ::DoControl call.

    TThreadMessage& m=Kern::Message();

    m.iValue = aReqNo;

    m.iArg[ KFirstParam ] = a1;

    m.iArg[ KSecondParam ] = NULL;

    result = m.SendReceive( &iMsgQ );

    C_TRACE( ( _T( "DP2PUserChannel::Request 0x%x 0x%x %d 0x%x %d<" ), this, iShP2PProtocolId, aReqNo, a1, result ) );

    return result;

    }

///// Functions from MChannelCallback start (from extension binary)

// called in router ext context

void DP2PUserChannel::ConnectionLost()

    {

    C_TRACE( ( _T( "DP2PKernelChannel::ConnectionLost 0x%x 0x%x %d %d 0x%x>" ), this, iShP2PProtocolId ) );

    EnqueChannelRequestCompleteDfc( EP2PAsyncConnectionLost, KErrNotReady );

    ResetQueues();

    //Closing();

    C_TRACE( ( _T( "DP2PKernelChannel::ConnectionLost 0x%x 0x%x %d %d 0x%x<" ), this, iShP2PProtocolId ) );

    }

// called in router ext context

void DP2PUserChannel::EnqueChannelRequestCompleteDfc(

        TInt aRequest,

        TInt aStatusToComplete

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::EnqueChannelRequestCompleteDfc 0x%x 0x%x %d %d>" ), this, iShP2PProtocolId, aRequest, aStatusToComplete ) );

    ASSERT_THREAD_CONTEXT_ALWAYS( ( EP2PIUserChannelfNotThreadContext | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    TP2PReq req( static_cast<TP2PAsyncRequest>( aRequest ), aStatusToComplete );

    if( iP2PReqQueue->Add( req ) )

        {

        TRACE_ASSERT_INFO( !iCompleteChannelRequestDfc->Queued(), (TUint8)iShP2PProtocolId << KProtocolIdShift | (TUint16)aRequest );

        iCompleteChannelRequestDfc->Enque();

        }

    C_TRACE( ( _T( "DP2PUserChannel::EnqueChannelRequestCompleteDfc 0x%x 0x%x %d %d<" ), this, iShP2PProtocolId, aRequest, aStatusToComplete ) );

    }

// This is called in 1...N thread contextes

void DP2PUserChannel::ReceiveMsg(

        const TDesC8& aMessage

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::ReceiveMsg 0x%x 0x%x 0x%x>" ), this, iShP2PProtocolId, &aMessage ) );

    // Can only be called from thread context.

    ASSERT_THREAD_CONTEXT_ALWAYS( ( EP2PIUserChannelfNotThreadContext3 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    iRx->Add( aMessage );

    iEmptyRxQueueDfc->Enque();

    C_TRACE( ( _T( "DP2PUserChannel::ReceiveMsg 0x%x 0x%x 0x%x<" ), this, iShP2PProtocolId, &aMessage ) );

    }

///// Functions from MChannelCallback end (from extension binary)

// Run in P2P extension kernel thread context.

void DP2PUserChannel::Close(

        const TUint8 aP2PProtocolId

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::Close 0x%x 0x%x 0x%x>" ), this, iShP2PProtocolId, aP2PProtocolId ) );

    if( EP2PAmountOfProtocols != iShP2PProtocolId )

        {

        C_TRACE( ( _T( "DP2PKernelChannel::Close closing 0x%x 0x%x>" ), iShP2PProtocolId, aP2PProtocolId ) );

        iRouterIf->Close( aP2PProtocolId );

        }

    iShP2PProtocolId = EP2PAmountOfProtocols;

    C_TRACE( ( _T( "DP2PUserChannel::Close 0x%x 0x%x 0x%x<" ), this, iShP2PProtocolId, aP2PProtocolId ) );

    }

void DP2PUserChannel::Closing(

        // None

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::Closing 0x%x 0x%x 0x%x>" ), this, iShP2PProtocolId ) );

    ResetQueues();

    TInt err( Kern::MutexWait( *iShP2PProtocolIdMutex ) );

    ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EP2PUserChannelMutexWaitFailed2 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    if( EP2PAmountOfProtocols != iShP2PProtocolId )

        {

        // Cancel any outstanding request. // remember in asynch close not to close it asynhronously

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

            {

            if( iP2PReqQueue->GetReq( static_cast< TP2PAsyncRequest >( i ) ) )

                {

                C_TRACE( ( _T( "DP2PUserChannel::Closing 0x%x 0x%x EP2PClose req to cancel" ), this, iShP2PProtocolId, i ) );

                DoCancel( KMaxTInt, i );

                }

            }

        Close( iShP2PProtocolId );

        }

    Kern::MutexSignal( *iShP2PProtocolIdMutex );

    C_TRACE( ( _T( "DP2PUserChannel::Closing 0x%x 0x%x 0x%x<" ), this, iShP2PProtocolId ) );

    }

// Run in P2P user channel kernel thread context.

void DP2PUserChannel::CompleteChReqDfc(

        TAny* aPtr

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::CompleteChReqDfc>" ) ) );

    // Make sure that user side is accessed only by ldd DFCThread.

    ASSERT_THREAD_CONTEXT_ALWAYS( ( EP2PIUserChannelfNotThreadContext2 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

    //TODO    ASSERT_DFCTHREAD_INLDD();

    DP2PUserChannel* chPtr = reinterpret_cast<DP2PUserChannel*>( aPtr );

    C_TRACE( ( _T( "DP2PUserChannel::CompleteChReqDfc 0x%x 0x%x" ), chPtr, chPtr->iShP2PProtocolId ) );

    TP2PReq requ = chPtr->iP2PReqQueue->Get();

    if( EP2PAsyncOpen == requ.iRequest )

        {

        C_TRACE( ( _T( "DP2PUserChannel::CompleteChReqDfc 0x%x 0x%x status %d" ), chPtr, chPtr->iShP2PProtocolId, requ.iCompleteStatus ) );

        // Check of KErrNone and KErrInUse (same object same id open) and in only those cases ~iCh = ~~iCh kernel already has.

        TInt err( Kern::MutexWait( *chPtr->iShP2PProtocolIdMutex ) );

        ASSERT_RESET_ALWAYS( ( KErrNone == err ), ( EP2PUserChannelMutexWaitFailed3 | EDP2PUserChannelTraceId << KClassIdentifierShift ) );

        TUint8 chNumber( ( KErrNone == requ.iCompleteStatus || KErrInUse == requ.iCompleteStatus ? ~chPtr->iShP2PProtocolId : EP2PAmountOfProtocols ) );

        chPtr->iShP2PProtocolId = chNumber;

        Kern::MutexSignal( *chPtr->iShP2PProtocolIdMutex );

        }

    TRequestStatus* status( chPtr->iP2PReqQueue->GetReq( requ.iRequest ) );

    Kern::RequestComplete( chPtr->iThread, status, requ.iCompleteStatus );

    C_TRACE( ( _T( "DP2PUserChannel::CompleteChReqDfc 0x%x 0x%x req %d status %d" ), chPtr, chPtr->iShP2PProtocolId, requ.iRequest, requ.iCompleteStatus ) );

    chPtr->iP2PReqQueue->SetReq( requ.iRequest, NULL );

    if( !chPtr->iP2PReqQueue->Empty() )

        {

        CompleteChReqDfc( chPtr );

        }

    C_TRACE( ( _T( "DP2PUserChannel::CompleteChReqDfc 0x%x 0x%x<" ), chPtr, chPtr->iShP2PProtocolId ) );

    }

void DP2PUserChannel::EmptyRxQueueDfc(

        TAny* aPtr // Pointer to self

        )

    {

// TODO    ASSERT_DFCTHREAD_INLDD();

    DP2PUserChannel& chTmp = *reinterpret_cast<DP2PUserChannel*>( aPtr );

    C_TRACE( ( _T( "DP2PUserChannel::EmptyRxQueueDfc 0x%x 0x%x>" ), &chTmp, chTmp.iShP2PProtocolId ) );

    if( ( chTmp.iP2PReqQueue->GetReq( EP2PAsyncReceive ) ) && ( chTmp.iRx->Count() > 0 ) )

        {

        TDes8& tmpDes = chTmp.iRx->Get();

        // Write to user address space (iReceiveBufPtr) the content of tmpDes starting from zero offset as 8bit descriptor data.

        TInt writeError( Kern::ThreadDesWrite( chTmp.iThread, chTmp.iReceiveBufPtr, tmpDes, KDestStartOffset, KChunkShiftBy0, chTmp.iThread ) );

        TRACE_ASSERT_INFO( writeError == KErrNone, ( chTmp.iShP2PProtocolId | writeError << KClassIdentifierShift ) );

        C_TRACE( ( _T( "DP2PUserChannel::EmptyRxQueueDfc writing 0x%x k>u 0x%x 0x%x writeError %d length %d" ), &tmpDes, chTmp.iReceiveBufPtr, chTmp.iShP2PProtocolId, writeError, tmpDes.Length() ) );

        TP2PReq req( static_cast<TP2PAsyncRequest>( EP2PAsyncReceive ), writeError );

        if( chTmp.iP2PReqQueue->Add( req ) )

            {

            TRACE_ASSERT( !chTmp.iCompleteChannelRequestDfc->Queued() );

            CompleteChReqDfc( &chTmp );

            }

        MemApi::DeallocBlock( tmpDes );

        }

    else

        {

        C_TRACE( ( _T( "DP2PUserChannel::EmptyRxQueueDfc 0x%x 0x%x rx inactive or no message" ), &chTmp, chTmp.iShP2PProtocolId ) );

        }

    C_TRACE( ( _T( "DP2PUserChannel::EmptyRxQueueDfc 0x%x 0x%x<" ), &chTmp, chTmp.iShP2PProtocolId ) );

    }

void DP2PUserChannel::ResetQueues(

        // None

        )

    {

    C_TRACE( ( _T( "DP2PUserChannel::ResetQueues 0x%x 0x%x>" ), this, iShP2PProtocolId ) );

    if( iRx )

        {

        C_TRACE( ( _T( "DP2PUserChannel::ResetQueues 0x%x 0x%x iRx 0x%x" ), this, iShP2PProtocolId, iRx ) );

        while( iRx->Count() )

            {

            MemApi::DeallocBlock( iRx->Get() );

            }

        }

    C_TRACE( ( _T( "DP2PUserChannel::ResetQueues 0x%x 0x%x<" ), this, iShP2PProtocolId ) );

    }

void DP2PUserChannel::HandleAsyncRequest(