/*

* 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 "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:  Routes data from peers to host and vice versa

*

*/

// INCLUDE FILES

#include "CSocketRouter.h"

#include "CommRouterDefinitions.h"

#include "MSocketRouterObserver.h"

#include "MBPProtocol.h"

#include "CProtocolTCP.h"

#include "CProtocolUDP.h"

#include "CLocalTCPConnection.h"

#include "CUDPSender.h"

#include "IPProxyEngine.pan"

#include <es_sock.h>

#define DEBUG_FILENAME "IPProxyEngine.log"

#include "DebugPrint.h"

// LOCAL CONSTANTS

const TInt KSocketRouterSlots = 60;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSocketRouter::CSocketRouter

// -----------------------------------------------------------------------------

//

CSocketRouter::CSocketRouter( MSocketRouterObserver* aObserver )

    : CActive( EPriorityIdle ), iObserver( aObserver )

    {

    __ASSERT_DEBUG( iObserver, User::Invariant() );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::ConstructL

// -----------------------------------------------------------------------------

//

void CSocketRouter::ConstructL()

    {

    User::LeaveIfError( iSocketServ.Connect( KSocketRouterSlots ) );

    iReceiveBuffer = HBufC8::NewL( 0 );

    iWriteEventArray = new (ELeave) CArrayPtrSeg<CWriteEvent> ( 10 );

    iPeerSocketArray = new (ELeave) CArrayPtrFlat<CSocket> ( 10 );

    iProtocolArray = new (ELeave) CArrayPtrFlat<MBPProtocol> ( 2 );

    // Add the protocols

    iProtocolTCP = CProtocolTCP::NewL( this );

    // takes the ownership

    iProtocolArray->AppendL( iProtocolTCP );

    iProtocolUDP = CProtocolUDP::NewL( this );

    // takes the ownership

    iProtocolArray->AppendL( iProtocolUDP );

    iUDPSender = CUDPSender::NewL( this );

    CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::NewL

// -----------------------------------------------------------------------------

//

CSocketRouter* CSocketRouter::NewL( MSocketRouterObserver* aObserver )

    {

    CSocketRouter* self = CSocketRouter::NewLC( aObserver );

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CSocketRouter::NewLC

// -----------------------------------------------------------------------------

//

CSocketRouter* CSocketRouter::NewLC( MSocketRouterObserver* aObserver )

    {

    CSocketRouter* self = new( ELeave ) CSocketRouter( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CSocketRouter::~CSocketRouter()

    {

    Cancel();

    delete iUDPSender;

    delete iReceiveBuffer;

    if ( iProtocolArray )

        {

        iProtocolArray->ResetAndDestroy();

        delete iProtocolArray;

        }

    if ( iPeerSocketArray )

        {

        iPeerSocketArray->ResetAndDestroy();

        delete iPeerSocketArray;

        }

    if ( iWriteEventArray )

        {

        iWriteEventArray->ResetAndDestroy();

        delete iWriteEventArray;

        }

    iSocketServ.Close();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::AddPeerSocketL

// -----------------------------------------------------------------------------

//

void CSocketRouter::AddPeerSocketL( RSocket* aSocket )

    {

    CSocket* newSocket = CSocket::NewLC( aSocket );

    newSocket->SetObserver( this );

    iPeerSocketArray->AppendL( newSocket );

    newSocket->SetSocketOwnershipMode( ETrue );

    DEBUG_PRINT( DEBUG_STRING(

        "CSocketRouter::AddPeerSocketL(), localport=%d, remote port=%d" ),

        newSocket->LocalPort(),

        newSocket->RemotePort() );

    CleanupStack::Pop( newSocket );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::AddUDPSocketL

// -----------------------------------------------------------------------------

//

void CSocketRouter::AddUDPSocketL( TUint aPort )

    {

    RSocket* newSocket = new (ELeave) RSocket();

    CleanupStack::PushL( newSocket );

    // Open the socket

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::AddUDPSocketL, Trying to open UDP port %d" ), aPort );

    User::LeaveIfError( newSocket->Open( iSocketServ, KAfInet, KSockDatagram,

        KProtocolInetUdp  ) );

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::AddUDPSocketL, UDP port opened." ), aPort );

    // Bind the  socket to the correct port.

    TInetAddr anyAddrOnPort( KInetAddrAny, aPort );

    newSocket->Bind( anyAddrOnPort );

    CSocket* cSocket = CSocket::NewLC( newSocket, aPort );

    cSocket->SetObserver( this );

    iPeerSocketArray->AppendL( cSocket );

    cSocket->SetSocketOwnershipMode( ETrue );

    CleanupStack::Pop( cSocket );

    CleanupStack::Pop( newSocket );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::RemovePeerSocket

// -----------------------------------------------------------------------------

//

void CSocketRouter::RemovePeerSocket( TInt aIndex )

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::RemovePeerSocket()" ) );

    CSocket* socket = iPeerSocketArray->At( aIndex );

    iPeerSocketArray->Delete( aIndex );

    delete socket;

    }

// -----------------------------------------------------------------------------

// CSocketRouter::RemovePeerSocket

// -----------------------------------------------------------------------------

//

void CSocketRouter::RemovePeerSocket( RSocket* aSocket )

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::RemovePeerSocket()" ) );

    TInt count = iPeerSocketArray->Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iPeerSocketArray->At( i )->GetRSocket() == aSocket )

            {

            iPeerSocketArray->Delete( i );

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CSocketRouter::FindPeerSocket

// -----------------------------------------------------------------------------

//

TInt CSocketRouter::FindPeerSocket( TUint aRemotePort )

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::FindPeerSocket()" ) );

    TInt count = iPeerSocketArray->Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iPeerSocketArray->At( i )->RemotePort() == aRemotePort )

            {

            return i;

            }

        }

    return -1;

    }

// -----------------------------------------------------------------------------

// CSocketRouter::RemoveAllPeers

// -----------------------------------------------------------------------------

//

void CSocketRouter::RemoveAllPeers()

    {

    iPeerSocketArray->ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::SocketCount

// -----------------------------------------------------------------------------

//

TInt CSocketRouter::SocketCount() const

    {

    return iPeerSocketArray->Count();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::SetHostSocketL

// -----------------------------------------------------------------------------

//

void CSocketRouter::SetHostSocketL( MSocket* aSocket )

    {

    DEBUG_PRINT( DEBUG_STRING(

        "CSocketRouter::SetHostSocketL()" ) );

    iHostSocket = aSocket;

    iHostSocket->SetObserver( this );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::RunL

// -----------------------------------------------------------------------------

//

void CSocketRouter::RunL()

    {

    WriteQueueL();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::DoCancel

// -----------------------------------------------------------------------------

//

void CSocketRouter::DoCancel()

    {

    }

// -----------------------------------------------------------------------------

// CSocketRouter::StartRouting

// -----------------------------------------------------------------------------

//

void CSocketRouter::StartRouting()

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::StartRouting()" ) );

    iRouting = ETrue;

    iHostSocket->IssueRead();

    TInt peerSocketArrayCount = iPeerSocketArray->Count();

    for ( TInt i = 0;i < peerSocketArrayCount; i++ )

        {

        CSocket* socket = iPeerSocketArray->At( i );

        socket->IssueRead();

        }

    IssueHandleQueue();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::IssueHandleQueue

// -----------------------------------------------------------------------------

//

void CSocketRouter::IssueHandleQueue()

    {

    if ( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

// -----------------------------------------------------------------------------

// CSocketRouter::StopRouting

// -----------------------------------------------------------------------------

//

void CSocketRouter::StopRouting()

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::StopRouting()" ) );

    Cancel();   //If HandleQueue is issued

    iRouting = EFalse;

    if ( iHostSocket )

        {

        iHostSocket->Cancel();

        }

    TInt peerSocketArrayCount = iPeerSocketArray->Count();

    for ( TInt i = 0;i < peerSocketArrayCount; i++ )

        {

        CSocket* socket = iPeerSocketArray->At( i );

        socket->Cancel();

        }

    }

// -----------------------------------------------------------------------------

// CSocketRouter::IsRouting

// -----------------------------------------------------------------------------

//

TBool CSocketRouter::IsRouting() const

    {

    return iRouting;

    }

// -----------------------------------------------------------------------------

// CSocketRouter::ResetQueue

// -----------------------------------------------------------------------------

//

void CSocketRouter::ResetQueue()

    {

    iWriteEventArray->ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CSocketRouter::SendCloseTCPConnection

// -----------------------------------------------------------------------------

//

void CSocketRouter::SendCloseTCPConnection( TUint aPort )

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::SendCloseTCPConnection" ) );

    iProtocolTCP->SendCloseTCPConnection( *iHostSocket, aPort );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::WriteCorrectFrame

// -----------------------------------------------------------------------------

//

void CSocketRouter::WriteCorrectFrameL( TProtocolDesc aProtocolDesc,

                        TUint aPeerPort,

                        TUint aOriginalPort,

                        const TDesC8& aData )

    {

    DEBUG_PRINT( DEBUG_STRING(

            "CSocketRouter::WriteCorrectFrameL(), protocol = %d" ),

            aProtocolDesc.iProtocol );

    MBPProtocol* protocol;

    if ( aProtocolDesc.iProtocol == KProtocolInetUdp )

        {

        // UDP frame

        DEBUG_PRINT( DEBUG_STRING(

            "CSocketRouter::WriteCorrectFrameL(), UDP" ) );

        protocol = iProtocolUDP;

        }

    else

        {

        // TCP frame

        DEBUG_PRINT( DEBUG_STRING(

            "CSocketRouter::WriteCorrectFrameL(), TCP" ) );

        protocol = iProtocolTCP;

        }

    protocol->WriteFrameL(

        *iHostSocket, aPeerPort,

        aOriginalPort, aData );

    }

// -----------------------------------------------------------------------------

// CSocketRouter::DataReceivedL

// -----------------------------------------------------------------------------

//

void CSocketRouter::DataReceivedL( const MSocket* aSocket, const TDesC8& aData )

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::DataReceivedL()" ) );

    __ASSERT_ALWAYS( aSocket, Panic( IPProxyEngineNullSocket ) );

    if ( iRouting )

        {

        //Route all data received from the host socket to protocol data handler.

        if ( aSocket == iHostSocket )

            {

            // join the previous buffer if there's something left

            TInt neededLength = iReceiveBuffer->Length() + aData.Length();

            HBufC8* joinedBuffers = HBufC8::NewLC( neededLength );

            TPtr8 joinedBuffersPtr( joinedBuffers->Des() );

            joinedBuffersPtr.Append( *iReceiveBuffer );

            joinedBuffersPtr.Append( aData );

            // Check if there's a protocol that can handle this message

            TInt length = 0; // length of the full msg

            TInt startPos = 0; // where the msg prefix starts

            TBool msgHandled = EFalse;

            TInt protCount = iProtocolArray->Count();

            for ( TInt i = 0; i < protCount && !msgHandled; i++ )

                {

                msgHandled = iProtocolArray->At( i )->HandleReceivedDataL(

                                                        joinedBuffersPtr,

                                                        startPos,

                                                        length  );

                }

            if ( msgHandled )

                {

                if ( length > 0 )

                    {

                    // Length is set only when whole msg is processed

                    // and correct.

                    // Store the rest of the msg for the next round

                    delete iReceiveBuffer;

                    iReceiveBuffer = NULL;

                    iReceiveBuffer =

                            joinedBuffers->Mid( startPos + length ).AllocL();

                    CleanupStack::PopAndDestroy( joinedBuffers );

                    if ( iReceiveBuffer->Length() > 0 )

                        {

                        // Start again to process the rest

                        iState = EStateWaitingFrameStart;

                        DataReceivedL( aSocket, KNullDesC8 );

                        }

                    }

                else

                    {

                    delete iReceiveBuffer;

                    iReceiveBuffer = joinedBuffers;

                    CleanupStack::Pop( joinedBuffers );

                    }

                }

            else

                {

                // Could not find a valid prefix for this protocol

                // store data for the next round

                HBufC8* newBuffer = HBufC8::NewLC( KMaxPrefixLength -1 );

                TPtr8 newBufferPtr( newBuffer->Des() );

                if ( joinedBuffersPtr.Length() > 3 )

                    {

                    newBufferPtr =

                        joinedBuffersPtr.Right( KMaxPrefixLength - 1 );

                    }

                else

                    {

                    iState = EStateWaitingFrameStart;

                    newBufferPtr = joinedBuffersPtr;

                    }

                delete iReceiveBuffer;

                iReceiveBuffer = newBuffer;

                CleanupStack::Pop( newBuffer );

                CleanupStack::PopAndDestroy( joinedBuffers );

                return;

                }

            }

        else    //Route all data received from any other socket to frame writer.

            {

            WriteQueueL();

            TProtocolDesc info;

            aSocket->SocketInfo( info );

            WriteCorrectFrameL(

                info, aSocket->RemotePort(),

                aSocket->LocalPort(), aData );

            }

        }

    else

        {

        //Add to queue

        TProtocolDesc desc;

        aSocket->SocketInfo( desc );

        iWriteEventArray->AppendL( CWriteEvent::NewLC( desc,

            aData, aSocket->RemotePort(), aSocket->LocalPort() ) );

        DEBUG_PRINT( DEBUG_STRING(

            "Add to queue: peerPort: %d. origPort: %d" ),

            aSocket->RemotePort(),

            aSocket->LocalPort() );

        CleanupStack::Pop(); // CWriteEvent

        }

    }

// -----------------------------------------------------------------------------

// CSocketRouter::WriteQueueL

// -----------------------------------------------------------------------------

//

void CSocketRouter::WriteQueueL()

    {

    DEBUG_PRINT( DEBUG_STRING( "CSocketRouter::WriteQueueL()" ) );

    TInt writeEventArrayCount = iWriteEventArray->Count();

    for ( TInt i = 0; i < writeEventArrayCount; i++ )

        {

        const CWriteEvent* writeEvent = iWriteEventArray->At( 0 );