/*

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