--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitylayer/isce/p2prouter_dll/src/p2pif.cpp Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,295 @@
+/*
+* 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 __ASSERT_CRITICAL published partner
+#include "p2pif.h" // For DP2PIf
+#include "p2proutertrace.h" // For ASSERT..
+#include "p2pinternaldefs.h" // For EP2PAsyncOpen etc..
+#include "p2pkernelchannel.h" // For DP2PKernelChannel
+
+// Constants
+const TInt KFirstParam( 0 );
+const TInt KSecondParam( 1 );
+const TInt KThirdParam( 2 );
+const TInt KOneParam( 2 );
+const TInt KTwoParams( 2 );
+const TInt KThreeParams( 3 );
+
+// Faults
+enum TP2PIfFaults
+ {
+ EP2PIfMemAllocFailure = 0x00,
+ EP2PIfMemAllocFailure2,
+ EP2PIfNotThreadContext,
+ EP2PIfNotThreadContext2,
+ EP2PIfNullParam,
+ EP2PIfNullPtr,
+ EP2PNotNullPtr,
+ EP2PIfWrongResponseToRequest,
+ EP2PIfWrongResponseToRequest2,
+ EP2PIfWrongResponseToRequest3,
+ EP2PIfWrongResponseToRequest4,
+ EP2PIfWrongResponseToRequest5,
+ EP2PIfWrongResponseToRequest6,
+ EP2PIfWrongResponseToRequest7,
+ EP2PIfWrongResponseToRequest8,
+ EP2PIfWrongResponseToRequest9,
+ };
+
+EXPORT_C MP2PIf* TP2PFactory::NewP2PIfF()
+ {
+
+ C_TRACE((_T("TP2PFactory::NewP2PIfF<>")));
+ return DP2PIf::NewF();
+
+ }
+
+DP2PIf* DP2PIf::NewF()
+ {
+
+ C_TRACE((_T("DP2PIf::NewF>") ));
+ DP2PIf* tmp = new DP2PIf();
+ ASSERT_RESET_ALWAYS( tmp, ( EP2PIfMemAllocFailure | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE((_T("DP2PIf::NewF 0x%x<"), tmp ));
+ return tmp;
+
+ }
+
+DP2PIf::DP2PIf(
+ // None
+ )
+ {
+
+ C_TRACE((_T("DP2PIf::DP2PIf 0x%x>"), this ));
+ __ASSERT_CRITICAL;// From kern_priv.h published partner
+ ASSERT_THREAD_CONTEXT_ALWAYS( ( EP2PIfNotThreadContext | EDP2PIfTraceId << KClassIdentifierShift ) );
+ iKernelChannel = new DP2PKernelChannel();
+ ASSERT_RESET_ALWAYS( iKernelChannel, ( EP2PIfMemAllocFailure2 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE((_T("DP2PIf::DP2PIf 0x%x<"), this ));
+
+ }
+
+DP2PIf::~DP2PIf(
+ // None
+ )
+ {
+
+ C_TRACE((_T("DP2PIf::~DP2PIf 0x%x>"), this ));
+ Close();
+ if( iKernelChannel )
+ {
+ delete iKernelChannel;
+ iKernelChannel = NULL;
+ }
+ C_TRACE((_T("DP2PIf::~DP2PIf 0x%x<"), this ));
+
+ }
+
+TDes8& DP2PIf::AllocateBlock(
+ const TUint16 aSize
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::AllocateBlock 0x%x %d>" ), this, aSize ) );
+ TDes8* temp = NULL;
+ TInt size( aSize );
+ TAny* params[ KTwoParams ];
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &size );
+ params[ KSecondParam ] = reinterpret_cast<TAny*>( &temp );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PAllocateBlock;
+ m.iArg[ KFirstParam ] = params;
+ // Other asserts in kernel channel.
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest4 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::AllocateBlock 0x%x %d<" ), this, aSize ) );
+ return *temp;
+
+ }
+
+void DP2PIf::Close(
+ // None
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::Close 0x%x>" ), this ) );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PClose;
+ m.iArg[ KFirstParam ] = NULL;
+ // Other asserts in kernel channel.
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::Close 0x%x<" ), this ) );
+
+ }
+
+void DP2PIf::ConnectionLost(
+ TInt& aStatus,
+ const TDfc& aConnectionResetedCompletedDfc
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::ConnectionLost 0x%x>" ), this, &aStatus, &aConnectionResetedCompletedDfc ) );
+ aStatus = KRequestPending;
+ TAny* params[ KTwoParams ];
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &aStatus );
+ params[ KSecondParam ] = reinterpret_cast<TAny*>( &const_cast<TDfc&>( aConnectionResetedCompletedDfc ) );
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PAsyncConnectionLost;
+ m.iArg[ KFirstParam ] = params;
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest8 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::ConnectionLost 0x%x<" ), this, &aStatus, &aConnectionResetedCompletedDfc ) );
+
+ }
+
+void DP2PIf::ConnectionLostCancel(
+ // None
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::ConnectionLostCancel 0x%x>" ), this ) );
+ TThreadMessage& m = Kern::Message();
+ m.iValue = KMaxTInt;
+ m.iArg[ KFirstParam ] = reinterpret_cast<TAny*>( EP2PAsyncConnectionLost );
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest9 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::ConnectionLostCancel 0x%x<" ), this ) );
+
+ }
+
+void DP2PIf::DeallocateBlock(
+ TDes8& aDataBlock
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::DeallocateBlock 0x%x b 0x%x>" ), this, &aDataBlock ) );
+ TAny* params[ KOneParam ];
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &aDataBlock );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PDeallocateBlock;
+ m.iArg[ KFirstParam ] = params;
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest5 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::DeallocateBlock 0x%x b 0x%x<" ), this, &aDataBlock ) );
+
+ }
+
+void DP2PIf::Open(
+ const TP2PProtocol aP2PProtocolId,
+ TInt& aDfcStatus,
+ TDfc& aOpenCompleteDfc
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::Open 0x%x 0x%x 0x%x %d 0x%x>" ), this, aP2PProtocolId, &aDfcStatus, aDfcStatus, &aOpenCompleteDfc ) );
+ TAny* params[ KThreeParams ];
+ aDfcStatus = KRequestPending;
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &aDfcStatus );
+ params[ KSecondParam ] = reinterpret_cast<TAny*>( &aOpenCompleteDfc );
+ params[ KThirdParam ] = reinterpret_cast<TAny*>( aP2PProtocolId );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PAsyncOpen;
+ m.iArg[ KFirstParam ] = params;
+ // Other asserts in kernel channel.
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest2 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::Open 0x%x 0x%x 0x%x %d 0x%x<" ), this, aP2PProtocolId, &aDfcStatus, aDfcStatus, &aOpenCompleteDfc ) );
+
+ }
+
+void DP2PIf::OpenCancel(
+ // None
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::OpenCancel 0x%x>"), this ) );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = KMaxTInt;
+ m.iArg[ KFirstParam ] = reinterpret_cast<TAny*>( EP2PAsyncOpen );
+ // Other asserts in kernel channel.
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest3 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::OpenCancel 0x%x<"), this ) );
+
+ }
+
+void DP2PIf::Receive(
+ TDes8*& aRxDataBlock,
+ TInt& aStatus,
+ const TDfc& aReceiveCompletedDfc
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::Receive 0x%x 0x%x 0x%x 0x%x>"), this, aRxDataBlock, &aStatus, &aReceiveCompletedDfc ) );
+ ASSERT_RESET_ALWAYS( !aRxDataBlock, ( EP2PNotNullPtr | EDP2PIfTraceId << KClassIdentifierShift ) );
+ aStatus = KRequestPending;
+ TAny* params[ KThreeParams ];
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &aStatus );
+ params[ KSecondParam ] = reinterpret_cast<TAny*>( &const_cast<TDfc&>( aReceiveCompletedDfc ) );
+ params[ KThirdParam ] = reinterpret_cast<TAny*>( &aRxDataBlock );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PAsyncReceive;
+ m.iArg[ KFirstParam ] = params;
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest6 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::Receive 0x%x 0x%x 0x%x 0x%x<"), this, aRxDataBlock, &aStatus, &aReceiveCompletedDfc ) );
+
+ }
+
+void DP2PIf::ReceiveCancel()
+ {
+
+ C_TRACE( ( _T( "DP2PIf::ReceiveCancel 0x%x>" ), this ) );
+ TThreadMessage& m = Kern::Message();
+ m.iValue = KMaxTInt;
+ m.iArg[ KFirstParam ] = reinterpret_cast<TAny*>( EP2PAsyncReceive );
+ ASSERT_RESET_ALWAYS( ( KErrNone == iKernelChannel->HandleRequest( m ) ), ( EP2PIfWrongResponseToRequest7 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ C_TRACE( ( _T( "DP2PIf::ReceiveCancel 0x%x<" ), this ) );
+
+ }
+
+void DP2PIf::Release()
+ {
+
+ C_TRACE( ( _T( "DP2PIf::Release 0x%x>" ), this ) );
+ __ASSERT_CRITICAL;// From kern_priv.h published partner
+ ASSERT_THREAD_CONTEXT_ALWAYS( ( EP2PIfNotThreadContext2 | EDP2PIfTraceId << KClassIdentifierShift ) );
+ delete this;
+ C_TRACE( ( _T( "DP2PIf::Release 0x%x<" ), this ) );
+
+ }
+
+TInt DP2PIf::Send(
+ TDes8& aData
+ )
+ {
+
+ C_TRACE( ( _T( "DP2PIf::Send 0x%x b 0x%x>"), this, &aData ) );
+ TAny* params[ KOneParam ];
+ params[ KFirstParam ] = reinterpret_cast<TAny*>( &aData );
+ // Get's the current thread's thread message.
+ TThreadMessage& m = Kern::Message();
+ m.iValue = EP2PSend;
+ m.iArg[ KFirstParam ] = params;
+ TInt retValue( iKernelChannel->HandleRequest( m ) );
+ C_TRACE( ( _T( "DP2PIf::Send 0x%x b 0x%x %d<"), this, &aData, retValue ) );
+ return retValue;
+
+ }
+
+// End of file