/*

* Copyright (c) 2007-2008 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:    Handles socket connecting

*

*/

#include "natfwconnectivityapidefs.h"

#include "natfwsockethandler.h"

#include "natfwsocketsender.h"

#include "natfwsocketmediaconnwrapperlogs.h"

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

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

// CNATFWSocketHandler::CNATFWSocketHandler

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

//

CNATFWSocketHandler::CNATFWSocketHandler( TUint aPort ) : 

    CActive(EPriorityStandard), iPort( aPort ), iSendState ( EUnitialized ),

    iReceiveState( ENotReceiving )

    {   

    CActiveScheduler::Add(this);

    }

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

// CNATFWSocketHandler::ConstructL

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

//

void CNATFWSocketHandler::ConstructL(

    MNATFWSocketReceiverObserver& aRecObs,

    MNATFWSocketSenderObserver& aSendObs, TUint aProtocol )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::ConstructL" )

    __ASSERT_ALWAYS( KProtocolInetTcp == aProtocol || 

        KProtocolInetUdp == aProtocol, User::Leave( KErrArgument ) );

    iProtocol = aProtocol;

    iSender = CNATFWSocketSender::NewL( aSendObs, iProtocol );

    iReceiver = CNATFWSocketReceiver::NewL( aRecObs, iProtocol );

    }

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

// CNATFWSocketHandler* CNATFWSocketHandler::NewL

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

//

CNATFWSocketHandler* CNATFWSocketHandler::NewL( 

    MNATFWSocketReceiverObserver& aRecObs,

    MNATFWSocketSenderObserver& aSendObs, TUint aProtocol, TUint aPort )

    {

    CNATFWSocketHandler* self = CNATFWSocketHandler::NewLC( aRecObs, aSendObs,

        aProtocol, aPort );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWSocketHandler* CNATFWSocketHandler::NewLC

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

//

CNATFWSocketHandler* CNATFWSocketHandler::NewLC( 

    MNATFWSocketReceiverObserver& aRecObs, 

    MNATFWSocketSenderObserver& aSendObs, TUint aProtocol, TUint aPort )

    {

    CNATFWSocketHandler* self 

            = new( ELeave ) CNATFWSocketHandler( aPort );

    CleanupStack::PushL( self );

    self->ConstructL( aRecObs, aSendObs, aProtocol );

    return self;

    }

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

// CNATFWSocketHandler::~CNATFWSocketHandler()

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

//

CNATFWSocketHandler::~CNATFWSocketHandler()

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::~CNATFWSocketHandler" )   

    iMediaObserver = NULL;

    iTcpConnectionObserver = NULL;

    Cancel();    

    delete iSender;

    delete iReceiver;

    iSocket.Close();

    iListeningSocket.Close();

    }

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

// CNATFWSocketHandler::RunL( )

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

//

void CNATFWSocketHandler::RunL( )

    {

    __SOCKETMEDIACONNWRAPPER_INT1( 

        "CNATFWSocketHandler::RunL iStatus:", iStatus.Int() ) 

    if ( KErrNone == iStatus.Int() )

        {

        iSendState = EConnected;        

        }

    else

        {

        iSendState = EUnitialized;

        }

    iTcpConnectionObserver->ConnectingCompleted( iStatus.Int() );

    }

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

// CNATFWSocketHandler::DoCancel( )

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

//

void CNATFWSocketHandler::DoCancel( )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::DoCancel" )

    iSocket.CancelAll();

    if ( ETcpSetupPassive == iTcpConnectionType )

        {

        iListeningSocket.CancelAll();

        }

    }

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

// CNATFWSocketHandler::LocalAddress( )

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

//

void CNATFWSocketHandler::LocalAddress( TSockAddr& aSocketToSendForPeer )

    {

    __SOCKETMEDIACONNWRAPPER_ADDRLOG(

    "CNATFWSocketHandler::LocalAddress - Local IP Address: ", iLocalAddress )

    aSocketToSendForPeer = iLocalAddress;

    }

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

// CNATFWSocketHandler::GetRemoteAddress( )

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

//

void CNATFWSocketHandler::GetRemoteAddress( TSockAddr& aRemoteAddress )

    {

    __SOCKETMEDIACONNWRAPPER_ADDRLOG(

    "CNATFWSocketHandler::GetRemoteAddress - Remote IP Address: ", iRemoteAddress )

    aRemoteAddress = iRemoteAddress;

    }

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

// CNATFWSocketHandler::SetAddrL( )

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

//

void CNATFWSocketHandler::SetAddrL( const TSockAddr& aSocketToSendForPeer )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::SetAddrL" )

    __ASSERT_ALWAYS( EUnitialized == iSendState, User::Leave( KErrArgument ) );

    if ( KAfInet6 == aSocketToSendForPeer.Family() )

        {

        iRemoteAddress.SetAddress( KInet6AddrLoop );

        }

    else

        {

        iRemoteAddress.SetAddress( INET_ADDR( 127, 0, 0, 1 ) );

        }

    iRemoteAddress.SetPort( aSocketToSendForPeer.Port() );

    TBool requiredPortOpen( EFalse );

    TInt error( KErrNone );

    if ( KProtocolInetTcp == iProtocol )

        {

        User::LeaveIfError( iSocket.Open( iSocketServer,

        KAfInet, KSockStream, KProtocolInetTcp ));

        }

    else if ( KProtocolInetUdp == iProtocol )

        {

        User::LeaveIfError( iSocket.Open( iSocketServer,

        KAfInet, KSockDatagram, KProtocolInetUdp ));

        }

    else

        {

        // Nothing to do here

        }

    while ( !requiredPortOpen )

        {

        if ( KProtocolInetUdp == iProtocol )

            {

            error = iSocket.SetLocalPort( iLocalAddress.Port() );

            }

        if ( KProtocolInetTcp == iProtocol )

            {

            error = iSocket.Bind( iLocalAddress );

            }

        if ( KErrNone != error )

            {

            TUint port( 0 );

            iMediaObserver->GetNewFreePort( port );

            iLocalAddress.SetPort( port );

            }

        else

            {

            requiredPortOpen = ETrue; 

            }

        }

    if ( KProtocolInetUdp == iProtocol )

        {

        iSendState = EConnected;

        }

    __SOCKETMEDIACONNWRAPPER_ADDRLOG( "Remote IP Address: ", iRemoteAddress )

    __SOCKETMEDIACONNWRAPPER_ADDRLOG( "Local IP Address: ", iLocalAddress )

    }

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

// CNATFWSocketHandler::SetReceivingStateL( )

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

//

void CNATFWSocketHandler::SetReceivingStateL( )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::SetReceivingStateL" )

    __ASSERT_ALWAYS( EConnected == iSendState || ESending == iSendState,

        User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( iReceiveState == ENotReceiving,

        User::Leave( KErrInUse ) );    

    if ( ETcpSetupPassive == iTcpConnectionType )

        {

        iReceiver->StartListening( iListeningSocket );

        }

    else

        {

        iReceiver->StartListening( iSocket );

        }

    iReceiveState = EReceiving;         

    }     

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

// CNATFWSocketHandler::SetSendingStateL( )

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

//

void CNATFWSocketHandler::SetSendingStateL( )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::SetSendingStateL" )

    __ASSERT_ALWAYS( EConnected == iSendState, User::Leave( KErrNotReady ) );

    if ( ETcpSetupPassive == iTcpConnectionType )

        {

        iSender->SetRemoteAddress( iRemoteAddress, iListeningSocket );

        }

    else

        {

        iSender->SetRemoteAddress( iRemoteAddress, iSocket );

        } 

    iSendState = ESending;

    }  

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

// CNATFWSocketHandler::SetReceivingStateForMuxWrapper( )

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

//

void CNATFWSocketHandler::SetReceivingStateForMuxWrapper(

    TNATFWStreamingState aState )

    {

    __SOCKETMEDIACONNWRAPPER(

        "CNATFWSocketHandler::SetReceivingStateForMuxWrapper" )

    iReceiver->SetReceivingStateForMuxWrapper( aState );

    }    

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

// CNATFWSocketHandler::SendL( )

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

//

void CNATFWSocketHandler::SendL( const TDesC8& aStreamPortion )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::SendL" )

    __ASSERT_ALWAYS( ESending == iSendState, User::Leave( KErrNotReady ) );

    iSender->SendL( aStreamPortion );

    } 

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

// CNATFWSocketHandler::SetLocalAddress( )

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

//    

void CNATFWSocketHandler::SetLocalAddress( 

    const RSocketServ& aSocketServer, const TSockAddr& /*aLocalAddress*/ )

    {

    iSocketServer = aSocketServer;  

    iLocalAddress.SetAddress( INET_ADDR( 127, 0, 0, 1 ) );

    iLocalAddress.SetPort( iPort );

    }

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

// CNATFWSocketHandler::SetMediaObserverL( )

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

//    

void CNATFWSocketHandler::SetMediaObserverL( 

    MNATFWMediaWrapperObserver* aMediaObserver )

    {

    __ASSERT_ALWAYS( aMediaObserver, User::Leave( KErrNotReady ) );

    iMediaObserver = aMediaObserver;

    }

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

// CNATFWSocketHandler::DeactivateSending(  )

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

//

void CNATFWSocketHandler::DeactivateSending(  )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::DeactivateSending" )

    iSender->Cancel();

    iSendState = EConnected;

    }

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

// CNATFWSocketHandler::DeactivateReceiving(  )

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

//

void CNATFWSocketHandler::DeactivateReceiving(  )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::DeactivateReceiving" )

    iReceiver->Cancel();

    iReceiveState = ENotReceiving;

    }

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

// CNATFWSocketHandler::OpenTcpConnectionL()

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

//

void CNATFWSocketHandler::OpenTcpConnectionL(

    TNATFWTcpConnectionSetup aSetup, MNsmcwTcpConnectionObserver& aObserver )

    {

    __SOCKETMEDIACONNWRAPPER( "CNATFWSocketHandler::OpenTcpConnectionL" )

    __ASSERT_ALWAYS( EUnitialized == iSendState, User::Leave( KErrInUse ) );

    iTcpConnectionType = aSetup;

    iTcpConnectionObserver = &aObserver;

    if ( ETcpSetupActive == iTcpConnectionType )  

        {

        iSocket.Connect( iRemoteAddress, iStatus );

        }

    if ( ETcpSetupPassive == iTcpConnectionType ) 

        {        

        User::LeaveIfError( iSocket.Listen( 1 ) );

        User::LeaveIfError( iListeningSocket.Open( iSocketServer ) );

        iSocket.Accept( iListeningSocket, iStatus );

        }

    iSendState = EGettingConnection;

    SetActive();  

    }

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

// CNATFWSocketHandler::CloseTcpConnection()

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

//

void CNATFWSocketHandler::CloseTcpConnection()

    {

    __SOCKETMEDIACONNWRAPPER(

        "CNATFWSocketHandler::CloseTcpConnection" )

    Cancel();

    iSendState = EUnitialized;

    iTcpConnectionObserver->ConnectingCompleted( KErrCancel );

    }