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