--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dvrengine/CommonRecordingEngine/src/CCRSock.cpp Thu Dec 17 09:14:38 2009 +0200
@@ -0,0 +1,913 @@
+/*
+* Copyright (c) 2007 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: Handles tcp/udp socket*
+*/
+
+
+
+
+// INCLUDE FILES
+#include "CCRSock.h"
+#include "videoserviceutilsLogger.h"
+
+// CONSTANTS
+_LIT( KCRSockLocalhost, "127.0.0.1" );
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CCRSock::CCRSock
+// C++ default constructor can NOT contain any code, that might leave.
+// -----------------------------------------------------------------------------
+//
+CCRSock::CCRSock(
+ MCRSockObserver& aObserver,
+ TInt aSockId,
+ RConnection& aConnection,
+ RSocketServ& aSockServer,
+ TBool aProtoTCP,
+ TBool aIssueRead )
+ : CActive( CActive::EPriorityStandard ),
+ iSockServer( aSockServer ),
+ iSockStatus( CCRSock::EInitNeeded ),
+ iObserver( aObserver ),
+ iSockId( aSockId ),
+ iProtoTCP( aProtoTCP ),
+ iIssueRead( aIssueRead ),
+ iReceivedData( NULL, 0 ),
+ iSentData( NULL, 0 ),
+ iConnection( aConnection )
+ {
+ // None
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CCRSock* CCRSock::NewL(
+ MCRSockObserver& aObserver,
+ TInt aSockId,
+ RConnection& aConnection,
+ RSocketServ& aSockServer,
+ TBool aProtoTCP,
+ TBool aIssueRead )
+ {
+ CCRSock* self = new( ELeave ) CCRSock( aObserver, aSockId, aConnection,
+ aSockServer, aProtoTCP, aIssueRead );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CCRSock::ConstructL()
+ {
+ LOG( "CCRSock::ConstructL() in" );
+
+ iReceivedDataBuf = HBufC8::NewL( KMaxDataSize );
+ iReceivedData.Set( iReceivedDataBuf->Des() );
+ iSentDataBuf = HBufC8::NewL( KMaxDataSize );
+ iSentData.Set( iSentDataBuf->Des() );
+
+ // Add self to active scheduler
+ CActiveScheduler::Add( this );
+ if ( iIssueRead )
+ {
+ iReader = CCRSockReader::NewL( *this, iConnection, iSockServer );
+ }
+
+ iToAddr.SetPort( 0 );
+
+ LOG( "CCRSock::ConstructL() out" );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::~CCRSock
+// Destructor.
+// -----------------------------------------------------------------------------
+//
+CCRSock::~CCRSock()
+ {
+ LOG( "CCRSock::~CCRSock()" );
+
+ CleanUp();
+ delete iReader;
+ delete iSentDataBuf;
+ delete iReceivedDataBuf;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CCRSock::RunL
+// "Brain"
+// -----------------------------------------------------------------------------
+//
+void CCRSock::RunL()
+ {
+ TInt err( KErrNone );
+
+ if ( iStatus == KErrEof && iWasListening )
+ {
+ iSocket.Close();
+ err = iSocket.Open( iSockServer );
+ if ( err == KErrNone )
+ {
+ LOG1( "CCRSock::RunL(), reopening sock: %d for listen", iSockId );
+ iIsiSocketOpen = ETrue;
+ iListenSocket.Accept( iSocket, iStatus );
+ iSockStatus = CCRSock::EListening;
+ SetActive();
+ }
+ else
+ {
+ LOG2( "CCRSock::RunL(), iSocket.Open FAILED id: %d err: %d",
+ iSockId, err );
+ }
+ }
+ else
+ {
+ switch ( iSockStatus )
+ {
+ case EResolving: // in connection, this is usually 1st time to come to RunL
+ if ( iStatus == KErrNone )
+ { // host name found
+ iHostAddress().iAddr.SetPort( iPort );
+ iSocket.Close();
+ err = iSocket.Open( iSockServer,
+ KAfInet,
+ iProtoTCP ? KSockStream : KSockDatagram,
+ iProtoTCP ? KProtocolInetTcp : KProtocolInetUdp,
+ iConnection ) ;
+ if ( err )
+ {
+ iSockStatus = CCRSock::EFailed;
+ iObserver.SockStatusChange( iSockId, iSockStatus, err );
+ iResolver.Close();
+ LOG2( "CCRSock::RunL(), iSockId: %d, err: %d", iSockId, err );
+ }
+ else
+ {
+ iIsiSocketOpen = ETrue;
+ if ( iLocalPort > 0 )
+ {
+ TInetAddr bindAddr( KInetAddrAny, iLocalPort );
+ err = iSocket.Bind( bindAddr );
+ if ( err != KErrNone )
+ {
+ LOG2( "CCRSock::ConnectSock(), Bind FAILED, Id: %d, err %d", iSockId, err );
+ }
+ }
+
+ LOG2( "CCRSock::RunL(), iSockId: %d, port: %d",
+ iSockId, iHostAddress().iAddr.Port() );
+ iSocket.Connect( iHostAddress().iAddr, iStatus );
+ iToAddr = iHostAddress().iAddr;
+ err = iSocket.SetOpt( KSOBlockingIO, KSOLSocket);
+ if ( err != KErrNone )
+ {
+ LOG1( "CCRSock::RunL(), iSocket.SetOpt FAILED: %d", err );
+ }
+ iSockStatus = CCRSock::EConnecting;
+ iObserver.SockStatusChange( iSockId, iSockStatus, err );
+ SetActive();
+ iResolver.Close();
+ }
+ }
+ else
+ { // resolving not ok
+ iSockStatus = CCRSock::EFailed;
+ iObserver.SockStatusChange( iSockId, iSockStatus, iStatus.Int() );
+ iResolver.Close();
+ }
+ break;
+
+ case EConnecting:
+ if ( iStatus == KErrNone ) // success
+ {
+ iSockStatus = CCRSock::EIdle;
+ // next action is up to user, don't do SetActive here.
+ LOG1( "CCRSock::RunL(), iSockId: %d", iSockId );
+
+ if ( iIssueRead && iReader && ( !iReader->IsActive() ) )
+ {
+ iReader->IssueRead();
+ }
+ }
+ else
+ {
+ iSockStatus = CCRSock::EFailed;
+ iObserver.SockStatusChange( iSockId, iSockStatus, iStatus.Int() );
+ CleanUp(); /* close everything */
+ }
+ iObserver.SockStatusChange( iSockId, iSockStatus, iStatus.Int() );
+ break;
+
+ case ESending:
+ // send has been finished,somehow:
+ if ( iStatus == KErrNone ) // success
+ {
+#if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )
+ sendBytes += iSentDataLen();
+ sendCount ++;
+ if ( ( sendCount % 50 ) == 0 )
+ {
+ LOG3( "CCRSock::RunL(), sendCount: %d, sendBytes: %d, iSockId: %d",
+ sendCount, sendBytes, iSockId );
+ }
+#endif
+ iSockStatus = CCRSock::EIdle;
+ // next action is up to user, don't do SetActive here.
+ }
+ else
+ {
+ iSockStatus = CCRSock::EFailed;
+ CleanUp(); /* close everything */
+ }
+ iObserver.SockStatusChange( iSockId, iSockStatus, iStatus.Int() );
+ break;
+
+ case EListening:
+ if ( iStatus == KErrNone ) // success, da zocket is open
+ {
+ iSockStatus = CCRSock::EIdle;
+ if ( iIssueRead && iReader && ( !iReader->IsActive() ) )
+ {
+ iReader->IssueRead();
+ }
+ }
+ else
+ {
+ iSockStatus = CCRSock::EFailed;
+ CleanUp(); /* close everything */
+ }
+ iObserver.SockStatusChange( iSockId, iSockStatus, iStatus.Int() );
+ break;
+
+ default:
+ __ASSERT_DEBUG( 1==2, User::Panic( _L("CRRTP"), KErrArgument) );
+ break; /* this should not happend? */
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::DoCancel
+// Cancels pending actions
+// -----------------------------------------------------------------------------
+//
+void CCRSock::DoCancel()
+ {
+ LOG( "CCRSock::DoCancel() in" );
+ if ( iIsiSocketOpen )
+ {
+ iSocket.CancelAll();
+ }
+ if ( iIsiListenSocketOpen )
+ {
+ iListenSocket.CancelAll();
+ }
+
+ LOG( "CCRSock::DoCancel() out" );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::CopySendData
+// Handles send buffer size.
+// -----------------------------------------------------------------------------
+//
+void CCRSock::CopySendData( const TDesC8& aData )
+ {
+ if ( aData.Length() > iSentData.MaxLength() )
+ {
+ // Alloc more than 8k
+ delete iSentDataBuf; iSentDataBuf = NULL;
+ iSentDataBuf = HBufC8::New( aData.Length() );
+ iSentData.Set( iSentDataBuf->Des() );
+ }
+ else
+ {
+ if ( iSentData.MaxLength() > KMaxDataSize &&
+ aData.Length() <= KMaxDataSize )
+ {
+ // Back to 8k if not more needed
+ delete iSentDataBuf; iSentDataBuf = NULL;
+ iSentDataBuf = HBufC8::New( KMaxDataSize );
+ iSentData.Set( iSentDataBuf->Des() );
+ }
+ }
+
+ iSentData.Copy( aData );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::CleanUp
+// Performs cleanup
+// -----------------------------------------------------------------------------
+//
+void CCRSock::CleanUp()
+ {
+ LOG( "CCRSock::CleanUp() in" );
+ Cancel();
+
+ iResolver.Close();
+ iSocket.Close();
+ iListenSocket.Close();
+ iSockStatus = CCRSock::EInitNeeded;
+
+ iIsiSocketOpen = EFalse;
+ iIsiListenSocketOpen = EFalse;
+ LOG( "CCRSock::CleanUp() out" );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::RunError
+// Q: Is anything wrong
+// A: Thanks for asking. About everything.
+// -----------------------------------------------------------------------------
+//
+TInt CCRSock::RunError( TInt aError )
+ {
+ LOG1( "CCRSock::RunError(), aError: %d", aError );
+ ( void )aError; // Prevent compiler warning
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::ConnectSock
+// Initiates connection to remote addr.
+// -----------------------------------------------------------------------------
+//
+TInt CCRSock::ConnectSock(
+ const TDesC& aAddr,
+ TUint aPort,
+ TInt aLocalPort )
+ {
+ LOG( "CCRSock::ConnectSock()" );
+
+ TInt retval( KErrNone );
+ if ( IsActive() )
+ {
+ retval = KErrInUse;
+ }
+ else
+ {
+ iWasListening = EFalse;
+ iPort = aPort;
+ iLocalPort = aLocalPort;
+ if ( aAddr.Compare( KCRSockLocalhost() ) != 0 )
+ {
+ iResolver.Close();
+ if ( (retval = iResolver.Open( iSockServer, KAfInet,
+ KProtocolInetTcp, iConnection) ) == KErrNone )
+ {
+ iResolver.GetByName( aAddr, iHostAddress, iStatus );
+ iSockStatus = CCRSock::EResolving;
+ SetActive();
+ }
+ else
+ {
+ LOG2( "CCRSock::ConnectSock(), Resolver.Open id: %d, err: %d",
+ iSockId, retval );
+ iSockStatus = CCRSock::EFailed;
+ }
+ }
+ else
+ { // localhost, no need to resolve
+ iHostAddress().iAddr.SetPort( iPort );
+ iSocket.Close();
+ retval = iSocket.Open( iSockServer,
+ KAfInet,
+ iProtoTCP ? KSockStream : KSockDatagram,
+ iProtoTCP ? KProtocolInetTcp : KProtocolInetUdp,
+ iConnection ) ;
+ if ( retval )
+ {
+ LOG2( "CCRSock::ConnectSock(), Socket.Open id: %d, err: %d",
+ iSockId, retval );
+ iSockStatus = CCRSock::EFailed;
+ }
+ else
+ {
+ iIsiSocketOpen = ETrue;
+ iSockStatus = CCRSock::EConnecting;
+ if ( aLocalPort > 0 )
+ {
+ TInetAddr bindAddr( KInetAddrAny, aLocalPort );
+ TInt err( iSocket.Bind( bindAddr ) );
+ if ( err != KErrNone )
+ {
+ LOG2( "CCRSock::ConnectSock(), Bind FAILED iSockId: %d, err: %d",
+ iSockId, err );
+ }
+ }
+ iToAddr = TInetAddr( KInetAddrLoop, aPort );
+ LOG2( "CCRSock::ConnectSock(), iSockId %d port %d",
+ iSockId, aPort );
+ iSocket.Connect( iToAddr, iStatus );
+ SetActive();
+ if ( iProtoTCP )
+ {
+ retval = iSocket.SetOpt( KSOBlockingIO, KSOLSocket );
+ }
+ iObserver.SockStatusChange( iSockId, iSockStatus, retval );
+ }
+ }
+ }
+
+ LOG1( "CCRSock::ConnectSock(), retVal: %d", retval );
+ return retval;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::ConnectSock
+// Initiates connection to remote addr without resolving.
+// -----------------------------------------------------------------------------
+//
+TInt CCRSock::ConnectSock(
+ const TSockAddr& aAddr,
+ TInt aLocalPort )
+ {
+ LOG( "CCRSock::ConnectSock(), no dns" );
+
+ TInt retval( KErrNone );
+ if ( IsActive() )
+ {
+ retval = KErrInUse;
+ }
+ else
+ {
+ iWasListening = EFalse;
+ iPort = aAddr.Port();
+ iLocalPort = aLocalPort;
+ iHostAddress().iAddr = aAddr;
+ iSocket.Close();
+ retval = iSocket.Open( iSockServer,
+ KAfInet,
+ iProtoTCP ? KSockStream : KSockDatagram,
+ iProtoTCP ? KProtocolInetTcp : KProtocolInetUdp,
+ iConnection ) ;
+ if ( retval )
+ {
+ LOG2( "CCRSock::ConnectSock(), Socket.Open id: %d, err: %d",
+ iSockId, retval );
+ iSockStatus = CCRSock::EFailed;
+ }
+ else
+ {
+ iIsiSocketOpen = ETrue;
+ iSockStatus = CCRSock::EConnecting;
+ if ( aLocalPort > 0 )
+ {
+ TInetAddr bindAddr( KInetAddrAny, aLocalPort );
+ TInt err( iSocket.Bind( bindAddr ) );
+ if ( err != KErrNone )
+ {
+ LOG2( "CCRSock::ConnectSock(), Bind FAILED id: %d err: %d",
+ iSockId, err );
+ }
+ }
+ iToAddr = aAddr;
+ LOG2( "CCRSock::ConnectSock(), id: %d, port: %d", iSockId, iPort );
+ iSocket.Connect( iToAddr, iStatus );
+ SetActive();
+ if ( iProtoTCP )
+ {
+ retval = iSocket.SetOpt( KSOBlockingIO, KSOLSocket );
+ }
+ iObserver.SockStatusChange( iSockId, iSockStatus, retval );
+ }
+ }
+
+ LOG1( "CCRSock::ConnectSock(), retVal: %d", retval );
+ return retval;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::ListenPort
+// Starts listening to port. Synchronous.
+// -----------------------------------------------------------------------------
+//
+TInt CCRSock::ListenPort( TUint aPort )
+ {
+ LOG1( "CCRSock::ListenPort(), aPort: %d", aPort );
+
+ TInt retval( KErrNone );
+ if ( IsActive() )
+ {
+ return KErrInUse;
+ }
+ if ( iSockStatus != CCRSock::EInitNeeded )
+ {
+ return KErrNotReady;
+ }
+
+ iHostAddress().iAddr.SetPort( iPort );
+ iWasListening = ETrue;
+ if ( iProtoTCP )
+ {
+ iListenSocket.Close();
+ if ( ( retval = iListenSocket.Open( iSockServer, KAfInet,
+ KSockStream, KProtocolInetTcp, iConnection ) ) == KErrNone )
+ {
+ iIsiListenSocketOpen = ETrue;
+ TInetAddr listenAddr( KInetAddrAny, aPort );
+ LOG2( "CCRSock::ListenPort(), id: %d, port: %d", iSockId,(TInt)aPort);
+ retval = iListenSocket.Bind( listenAddr );
+ if ( retval == KErrNone )
+ {
+ retval = iListenSocket.Listen( 5 );
+ if ( retval == KErrNone )
+ {
+ iSocket.Close();
+ retval = iSocket.Open( iSockServer );
+ if ( retval == KErrNone )
+ {
+ iIsiSocketOpen = ETrue;
+ iListenSocket.Accept( iSocket, iStatus );
+ iSockStatus = CCRSock::EListening;
+ SetActive();
+ }
+ else
+ {
+ LOG1( "CCRSock::ListenPort(), iSocket.Open FAILED retval: %d", retval );
+ }
+ }
+ else
+ {
+ LOG1( "CCRSock::ListenPort(), iListenSock.Listen FAILED retval: %d", retval );
+ }
+ }
+ else
+ {
+ LOG2( "CCRSock::ListenPort() iListenSocket.Bind FAILED Id: %d, retval: %d", iSockId, retval);
+ }
+ }
+ else
+ {
+ LOG2( "ListenSocket.Open id: %d, err: %d", iSockId, retval );
+ }
+ }
+ else
+ {
+ // for UDP things are different: just open, bind
+ iSocket.Close();
+ if ( ( retval = iSocket.Open( iSockServer,
+ KAfInet,
+ KSockDatagram,
+ KProtocolInetUdp,
+ iConnection ) ) != KErrNone )
+ {
+ iSockStatus = CCRSock::EFailed;
+ LOG2( "CCRSock::ListenPort(), UDPSocket.Open id: %d, err: %d", iSockId, retval );
+ }
+ else
+ {
+ TInetAddr listenAddr( KInetAddrAny, aPort );
+ retval = iSocket.Bind( listenAddr );
+ if ( retval == KErrNone )
+ {
+ LOG2( "CCRSock::ListenPort(), udp: %d ok, id: %d", aPort,iSockId );
+ iSockStatus = CCRSock::EIdle;
+ iIsiSocketOpen = ETrue;
+ }
+ else
+ {
+ LOG2( "CCRSock::ListenPort(), UDPSocket.Bind FAILED id: %d, retval: %d", iSockId, retval );
+ iSockStatus = CCRSock::EFailed;
+ }
+ if ( iIssueRead && iReader && ( !iReader->IsActive() ) )
+ {
+ iReader->IssueRead();
+ }
+ }
+ }
+
+ LOG1( "CCRSock::ListenPort(), retval: %d", retval );
+ return retval;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::JoinGroup
+// Joins a multicast group. Synchronous.
+// -----------------------------------------------------------------------------
+//
+TInt CCRSock::JoinGroup( const TInetAddr& aGroupAddr )
+ {
+ LOG( "CCRSock::JoinGroup()" );
+
+ TPckgBuf<TIp6Mreq> request;
+ request().iAddr = aGroupAddr.Ip6Address();
+ request().iInterface = 0;
+ return iSocket.SetOpt( KSoIp6JoinGroup, KSolInetIp, request );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::SendData
+// Initiates async data sending
+// -----------------------------------------------------------------------------
+//
+void CCRSock::SendData( const TDesC8& aDataThatIsSentOverSocket )
+ {
+#if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )
+ if ( iProtoTCP && aDataThatIsSentOverSocket.Length() &&
+ aDataThatIsSentOverSocket[0] != ( TUint8 )( '$' ) )
+ {
+ LOG2("CCRSock::SendData(), id: %d, len: %d",
+ iSockId, aDataThatIsSentOverSocket.Length() );
+ TChar c;
+ TName d;
+ for ( TInt i( 0 ); i < aDataThatIsSentOverSocket.Length(); i++ )
+ {
+ c = aDataThatIsSentOverSocket[i];
+ d.Append( c );
+ if ( ( i > 0 ) && ( i % 80 ) == 0 )
+ {
+ LOG1( ">%S<", &d );
+ d.Zero();
+ }
+ }
+
+ LOG1( ">%S<", &d );
+ }
+#endif
+
+ // Data to socket
+ if ( !IsActive() )
+ {
+ CopySendData( aDataThatIsSentOverSocket );
+ if ( iProtoTCP )
+ {
+ iSocket.Write( iSentData, iStatus );
+ iSockStatus = CCRSock::ESending;
+ SetActive();
+ }
+ else
+ {
+ if ( iToAddr.Port() != 0 )
+ {
+ iSocket.SendTo( iSentData, iToAddr, 0, iStatus, iSentDataLen );
+ iSockStatus = CCRSock::ESending;
+ SetActive();
+ }
+ else
+ {
+ LOG1( "CCRSock::SendData(), Discarding send, id: %d" ,iSockId );
+ }
+ }
+ }
+ else
+ {
+ LOG2( "CCRSock::SendData(), id: %d, Already active, Dumped packet, len: %d" ,
+ iSockId, aDataThatIsSentOverSocket.Length() );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::SockStatus
+// returns status
+// -----------------------------------------------------------------------------
+//
+CCRSock::TCRSockStatus CCRSock::SockStatus() const
+ {
+ return iSockStatus;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::ConnectedAddr
+// returns endpoint addr of this sock
+// -----------------------------------------------------------------------------
+//
+TInetAddr CCRSock::ConnectedAddr( void )
+ {
+ TInetAddr addr;
+ iSocket.RemoteName( addr );
+ return addr;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::LocalAddr
+// returns local addr of this sock
+// -----------------------------------------------------------------------------
+//
+TInetAddr CCRSock::LocalAddr( void )
+ {
+ TInetAddr addr;
+ iSocket.LocalName( addr );
+ return addr;
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::SetToAddr
+// sets "to" addr of this sock
+// -----------------------------------------------------------------------------
+//
+void CCRSock::SetToAddr( const TInetAddr &aAddr )
+ {
+ LOG( "CCRSock::SetToAddr() in" );
+ iToAddr = aAddr;
+
+#if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )
+ TName an_addr;
+ iToAddr.Output( an_addr );
+ LOG3( "CCRSock::SetToAddr(), id: %d, addr: %S, port: %d", iSockId, &an_addr, aAddr.Port() );
+#endif
+
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::Socket
+// -----------------------------------------------------------------------------
+RSocket& CCRSock::Socket()
+ {
+ return iSocket;
+ }
+
+// -----------------------------------------------------------------------------
+// ----------- here begins implementation of "SockReader" helper class----------
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+
+// -----------------------------------------------------------------------------
+// CCRSockReader::NewL
+// Construction startpoint
+// -----------------------------------------------------------------------------
+//
+CCRSockReader* CCRSockReader::NewL(
+ CCRSock& aSock,
+ RConnection& aConnection, RSocketServ& aSockServer )
+ {
+ CCRSockReader* self = new ( ELeave ) CCRSockReader(
+ aSock, aConnection, aSockServer );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+// -----------------------------------------------------------------------------
+// CCRSockReader::CCRSockReader
+// Default constructor
+// -----------------------------------------------------------------------------
+//
+CCRSockReader::CCRSockReader(
+ CCRSock& aSock, RConnection& aConnection,
+ RSocketServ& aSockServer )
+ : CActive( EPriorityStandard ),
+ iSock( aSock ),
+ iConnection( aConnection ),
+ iSockServer( aSockServer )
+ {
+ }
+// -----------------------------------------------------------------------------
+// CCRSockReader::ConstructL
+// Actual constructor
+// -----------------------------------------------------------------------------
+//
+void CCRSockReader::ConstructL()
+ {
+ LOG( "CCRSockReader::ConstructL()" );
+
+ // Add self to active scheduler
+ CActiveScheduler::Add( this );
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSock::~CCRSockReader
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CCRSockReader::~CCRSockReader()
+ {
+ LOG( "CCRSockReader::~CCRSockReader()" );
+ Cancel();
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSockReader::RunL
+// Work-horse
+// -----------------------------------------------------------------------------
+//
+void CCRSockReader::RunL()
+ {
+#if defined ( LIVE_TV_FILE_TRACE ) || defined ( LIVE_TV_RDEBUG_TRACE )
+ if ( iSock.iProtoTCP && iStatus.Int() != KErrNone )
+ {
+ LOG2( "CCRSockReader::RunL(), id: %d, status: %d", iSock.iSockId, iStatus.Int() );
+ }
+#endif
+
+ switch ( iStatus.Int() )
+ {
+ case KErrNone:
+ {
+#if defined( LIVE_TV_FILE_TRACE ) || defined( LIVE_TV_RDEBUG_TRACE )
+ if ( !iSock.iProtoTCP )
+ {
+ recvBytes += iSock.iReceivedData.Length();
+ recvCount ++;
+ if ( ( recvCount % 50 ) == 0 )
+ {
+ LOG3( "CCRSockReader::RunL(), recvCount: %d, recvBytes: %d, id: %d",
+ recvCount, recvBytes, iSock.iSockId );
+ TName an_addr;
+ iSock.iFromAddr.Output( an_addr );
+ TInt a_byte2 = iSock.iReceivedData[2];
+ TInt a_byte3 = iSock.iReceivedData[3];
+ LOG3( "CCRSockReader::RunL(), Addr %S, port: %d, last seq: %d",
+ &an_addr, iSock.iFromAddr.Port(), ( a_byte2 * 255 ) + a_byte3 );
+ }
+ }
+#endif // LIVE_TV_FILE_TRACE || LIVE_TV_RDEBUG_TRACE
+
+ iSock.iObserver.DataReceived( iSock.iSockId, iSock.iReceivedData );
+ IssueRead();
+ }
+ break;
+
+ default: // error cases
+ {
+ LOG2( "CCRSockReader::RunL(), id: %d, status: %d", iSock.iSockId, iStatus.Int() );
+ iSock.iSockStatus = CCRSock::EFailed;
+ iSock.iObserver.SockStatusChange(
+ iSock.iSockId, iSock.iSockStatus, iStatus.Int() );
+ }
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSockReader::IssueRead
+// Asks for more data
+// -----------------------------------------------------------------------------
+//
+void CCRSockReader::IssueRead()
+ {
+ if ( IsActive() )
+ {
+ LOG( "CCRSockReader::IssueRead(), IsActive! return" );
+ return;
+ }
+
+ iSock.iReceivedData.Zero();
+ if ( iSock.iProtoTCP )
+ {
+ iSock.iSocket.RecvOneOrMore( iSock.iReceivedData, 0, iStatus,
+ iSock.iReceivedDataLen );
+ }
+ else
+ {
+ iSock.iSocket.RecvFrom( iSock.iReceivedData, iSock.iFromAddr, 0, iStatus );
+ }
+
+ SetActive();
+ }
+
+// -----------------------------------------------------------------------------
+// CCRSockReader::DoCancel
+// Cancels outstanding operations
+// -----------------------------------------------------------------------------
+//
+void CCRSockReader::DoCancel()
+ {
+ LOG( "CCRSockReader::DoCancel()" );
+ // CCRSock::DoCancel() has already called CancelAll to socket so no need to do it here
+ }
+// -----------------------------------------------------------------------------
+// CCRSockReader::RunError
+// If anything goes wrong
+// -----------------------------------------------------------------------------
+//
+TInt CCRSockReader::RunError( TInt aError )
+ {
+ LOG1( "CCRSockReader::RunError(), aError: %d, return KErrNone", aError );
+ ( void )aError; // Prevent compiler warning
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// ----------- here ends implementation of "SockReader" helper class----------
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+// End of File
+