/*
* 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 );
}