// Copyright (c) 2006-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:

// Name          : CNATTraversalControllerExampleExample.cpp

// Part of       : SIP NAT Traversal Controller Example

// Version       : 

//

#include "CNATTraversalControllerExample.h"

#include "sipnattraversalcontrollerinitparams.h"

#include "sipnatbindingobserver.h"

#include "sipnattraversalrequestobserver.h"

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

// CNATTraversalControllerExample::NewL

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

//

CNATTraversalControllerExample* CNATTraversalControllerExample::NewL(

    TAny* aInitParams)

	{

	__ASSERT_ALWAYS (aInitParams != NULL, User::Leave(KErrArgument));

	TSIPNATTraversalControllerInitParams* params =

		static_cast<TSIPNATTraversalControllerInitParams*>(aInitParams);

    CNATTraversalControllerExample* self = 

        new(ELeave)CNATTraversalControllerExample(params->iSocketServ);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

	}

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

// CNATTraversalControllerExample::CNATTraversalControllerExample

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

//

CNATTraversalControllerExample::CNATTraversalControllerExample(

    RSocketServ& aSocketServ)

 : iSocketServ(aSocketServ),

   iRequestOrder(TNATTraversalPendingRequest::RequestOrder)

	{

	}

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

// CNATTraversalControllerExample::ConstructL

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

//

void CNATTraversalControllerExample::ConstructL()

    {

    iDeltaTimer = CDeltaTimer::NewL(CActive::EPriorityStandard); 

    }

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

// CNATTraversalControllerExample::~CNATTraversalControllerExample

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

//

CNATTraversalControllerExample::~CNATTraversalControllerExample()

	{

	for (TInt i=0; i < iPendingRequests.Count(); i++)

	    {

	    if (iDeltaTimer)

	        {

	        iDeltaTimer->Remove(iPendingRequests[i].DeltaTimerEntry());

	        }

	    }

	iPendingRequests.Close();

	delete iDeltaTimer;

	}

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

// CNATTraversalControllerExample::ResolvePublicAddrL

// From CSIPNATTraversalController

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

//

TUint32 CNATTraversalControllerExample::ResolvePublicAddrL(

    TUint32 /*aIapId*/,

    RConnection& /*aConnection*/,

    const TInetAddr& /*aLocalAddr*/,

    const TDesC8& /*aDomain*/,

    RSocket& /*aUdpSocket*/,

    const TInetAddr& /*aNextHopAddr*/,

    MSIPNATBindingObserver* aBindingObserver,

    MSIPNATTraversalRequestObserver& aRequestObserver)

    {

    TUint32 requestId = NextRequestId();

    if (!BindingExists(aBindingObserver))

        {

        // Initiate actions to fetch the public IP address of aUdpSocket.

        // For example STUN protocol (RFC 3489) can be used for this purpose.

        // When the public IP address and port have been discovered

        // MSIPNATTraversalRequestObserver::PublicAddrResolved should be called.

        }

    else

        {

        // Start a timer with a minimum value to make the call asynchronous

        TNATTraversalPendingRequest request(requestId,&aRequestObserver,*this);

        iPendingRequests.InsertInOrderL(request,iRequestOrder);

        TInt index = iPendingRequests.FindInOrder(request,iRequestOrder);

        iDeltaTimer->Queue(1,iPendingRequests[index].DeltaTimerEntry());

        }

    return requestId;

    }

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

// CNATTraversalControllerExample::Cancel

// From CSIPNATTraversalController

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

//        

void CNATTraversalControllerExample::Cancel(TUint32 aRequestId)

    {

    TNATTraversalPendingRequest tmp(aRequestId,0,*this);

    TInt index = iPendingRequests.FindInOrder(tmp,iRequestOrder);

    if (index >= 0)

        {

        iDeltaTimer->Remove(iPendingRequests[index].DeltaTimerEntry());

        iPendingRequests.Remove(index);

        }

    else

        {

        // Cancel ongoing IP address discovery     

        }

    }

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

// CNATTraversalControllerExample::RefreshNATBindingL

// From CSIPNATTraversalController

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

//

TBool CNATTraversalControllerExample::RefreshNATBindingL(

    RSocket& aSocket,

    const MSIPNATBindingObserver* /*aBindingObserver*/)

    {

    TBool maintainPersistentConnection = EFalse;

    // If it was detected that the terminal is behind a NAT, 

    // some kind of NAT binding keepalive should be started.

    // Some suggestions about the keepalive mechanisms can be found from

    // http://www.ietf.org/internet-drafts/draft-ietf-sip-outbound-04.txt    

    // aBindingObserver can be used for notifying flow failures 

    // specified in the above draft.

    if (Protocol(aSocket) == KProtocolInetTcp)

        {

        // If it was found that the terminal is behind a NAT

        // and the protocol of aSocket is TCP, 

        // then maintainPersistentConnection should be set to ETrue

        // to keep the TCP connection open for NAT binding keepalive.

        }

	return maintainPersistentConnection;

    }

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

// CNATTraversalControllerExample::RefreshNATBindingL

// From CSIPNATTraversalController

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

//

TBool CNATTraversalControllerExample::RefreshNATBindingL(

    CSecureSocket& /*aSecureSocket*/,

    const MSIPNATBindingObserver* /*aBindingObserver*/)

    {

    TBool maintainPersistentConnection = EFalse;

    // If it was detected that the terminal is behind a NAT, 

    // some kind of NAT binding keepalive should be started and

    // maintainPersistentConnection should be set to ETrue

    // to keep the TLS connection open for NAT binding keepalive.

	return maintainPersistentConnection;

    }

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

// CNATTraversalControllerExample::UpdateNextHop

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::UpdateNextHop( 

    const TInetAddr& /*aNextHopAddr*/,

    const MSIPNATBindingObserver* /*aBindingObserver*/ )

    {

    // For UDP based NAT binding keepalives the destination

    // for the NAT binding keepalives may change.

    // The new address must be taken into use.

    }

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

// CNATTraversalControllerExample::SocketIdle

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::SocketIdle(

    TBool aIdle,

    RSocket& /*aSocket*/)

    {

    if (aIdle)

        {

        // SIP stack is not currently using aSocket for sending.

        // NAT bindings created with aSocket can be refreshed. 

        // See for example:

        // http://www.ietf.org/internet-drafts/draft-ietf-sip-outbound-04.txt

        }

    else

        {

        // SIP stack needs aSocket for sending.

        // It may not be used for refreshing NAT bindings 

        // and any outstanding request for aSocket must be cancelled 

        }    

    }

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

// CNATTraversalControllerExample::SocketIdle

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::SocketIdle(

    TBool aIdle,

    CSecureSocket& /*aSecureSocket*/)

    {

    if (aIdle)

        {

        // SIP stack is not currently using aSecureSocket for sending.

        // NAT bindings created with aSecureSocket can be refreshed. 

        // See for example:

        // http://www.ietf.org/internet-drafts/draft-ietf-sip-outbound-04.txt

        }

    else

        {

        // SIP stack needs aSecureSocket for sending.

        // It may not be used for refreshing NAT bindings 

        // and any outstanding request for aSocket must be cancelled 

        }

    }

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

// CNATTraversalControllerExample::DataReceived

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::DataReceivedL(

    const TDesC8& /*aData*/,

    const RSocket& /*aSocket*/,

    TBool& /*aHandled*/)

    {

    // SIP stack has received aData from aSocket.

    // This data has not been recognized as a SIP request nor SIP response.

    // This data can be for example a STUN response, 

    // if STUN is used for public IP address discovery or NAT bidning keepalive.

    }    

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

// CNATTraversalControllerExample::FreeResources

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::FreeResources(

    TUint32 /*aIapId*/)

    {

	// SIP stack is closing RConnection that is related to aIapId.

	// All the resources reserved using this RConnection must be freed

	// and the related sockets must not be used anymore. 

    }

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

// CNATTraversalControllerExample::FreeResources

// From CSIPNATTraversalController

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

//

void CNATTraversalControllerExample::FreeResources(

    MSIPNATBindingObserver& /*aBindingObserver*/)

    {

	// SIP stack is deleting aBindingObserver.

	// All the resources reserved using this aBindingObserver must be freed.

    }

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

// CNATTraversalControllerExample::RequestCompleted

// From MNATTraversalPendingRequestContainer

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

//    

void CNATTraversalControllerExample::RequestCompleted(

    TUint32 aRequestId)

    {

    TNATTraversalPendingRequest tmp(aRequestId,0,*this);

    TInt index = iPendingRequests.FindInOrder(tmp,iRequestOrder);

    if (index >= 0)

        {

        TNATTraversalPendingRequest request = iPendingRequests[index]; // copy

        iDeltaTimer->Remove(iPendingRequests[index].DeltaTimerEntry());

        iPendingRequests.Remove(index); // remove from array

        request.CompleteRequest(); // use copy for informing the observer

        }

    }

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

// CNATTraversalControllerExample::NextRequestId

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

//

TUint32 CNATTraversalControllerExample::NextRequestId()

	{

    if (iRequestIdCounter == KMaxTUint32)

		{

		iRequestIdCounter = 1;

		}

	else

		{

		iRequestIdCounter++;

		}

	return iRequestIdCounter;

	}

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

// CNATTraversalControllerExample::Protocol

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

//

TUint CNATTraversalControllerExample::Protocol(RSocket& aSocket) const

    {

    TProtocolDesc proto;

    aSocket.Info(proto);

    return proto.iProtocol;

    }

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

// CNATTraversalControllerExample::BindingExists

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

//   

TBool CNATTraversalControllerExample::BindingExists(

    const MSIPNATBindingObserver* /*aObserver*/) const

    {

	// Find NAT binding keepalive related to aObserver

	// If it exists, return ETrue.

	return ETrue;    

    }