/*

* 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 "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: 

*

*/

#include "cnattraversalsession.h"

#include "cnattraversalconfig.h"

#include "cnatbinding.h"

#include "cnatbindingstunrefresher.h"

#include "cnatbindingcrlfrefresher.h"

#include "cnatbindingstunandcrlfrefresher.h"

#include "cudpcrlfsender.h"

#include "ctcpcrlfsender.h"

#include "ctlscrlfsender.h"

#include "sipnatbindingobserver.h"

#include "nattraversallog.h"

_LIT8(KZeroIPAddress, "0.0.0.0");

// The following addresses are private (RFC 1918):

// 10.0.0.0 - 10.255.255.255

const TUint32 KPrivateRange1Low  = INET_ADDR(10,0,0,0);

const TUint32 KPrivateRange1High = INET_ADDR(10,255,255,255);

// 172.16.0.0 - 172.31.255.255

const TUint32 KPrivateRange2Low  = INET_ADDR(172,16,0,0);

const TUint32 KPrivateRange2High = INET_ADDR(172,31,255,255);

// 192.168.0.0 - 192.168.255.255

const TUint32 KPrivateRange3Low  = INET_ADDR(192,168,0,0);

const TUint32 KPrivateRange3High = INET_ADDR(192,168,255,255);

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

// CNATTraversalSession::NewL

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

//

CNATTraversalSession* CNATTraversalSession::NewL(

    CDeltaTimer& aDeltaTimer,

    RSocketServ& aSocketServ,

    RConnection& aConnection,

    const TInetAddr& aLocalAddr,

    const TInetAddr& aNextHopAddr,

    CNATTraversalConfig* aConfig,

    MSTUNClientObserver& aObserver,

    MNATTraversalSocketManager& aSocketManager)

    {

    CNATTraversalSession* self =

        CNATTraversalSession::NewLC(aDeltaTimer,aSocketServ,aConnection,

                                    aLocalAddr,aNextHopAddr,aConfig,

                                    aObserver,aSocketManager);

    CleanupStack::Pop(self);

    return self;

    }

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

// CNATTraversalSession::NewL

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

//

CNATTraversalSession* CNATTraversalSession::NewLC(

    CDeltaTimer& aDeltaTimer,

    RSocketServ& aSocketServ,

    RConnection& aConnection,

    const TInetAddr& aLocalAddr,

    const TInetAddr& aNextHopAddr,

    CNATTraversalConfig* aConfig,

    MSTUNClientObserver& aObserver,

    MNATTraversalSocketManager& aSocketManager)

    {

    CNATTraversalSession* self =

        new(ELeave)CNATTraversalSession(

            aLocalAddr,aNextHopAddr,aDeltaTimer,aSocketManager);

    CleanupStack::PushL(self);

    self->ConstructL(aSocketServ,aConnection,aConfig,aObserver);

    return self;

    }

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

// CNATTraversalSession::CNATTraversalSession

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

//

CNATTraversalSession::CNATTraversalSession(

    const TInetAddr& aLocalAddr,

    const TInetAddr& aNextHopAddr,

    CDeltaTimer& aDeltaTimer,

    MNATTraversalSocketManager& aSocketManager)

    : iLocalAddr(aLocalAddr),

      iNextHopAddr(aNextHopAddr),

      iDeltaTimer(aDeltaTimer),

      iSocketManager(aSocketManager)

    {

    }

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

// CNATTraversalSession::ConstructL

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

//

void CNATTraversalSession::ConstructL(

    RSocketServ& aSocketServ,

    RConnection& aConnection,

    CNATTraversalConfig* aConfig,

    MSTUNClientObserver& aObserver)

    {

    __ASSERT_ALWAYS(aConfig, User::Leave(KErrArgument));

    if (aConfig->STUNServer().Compare(KZeroIPAddress) == 0)

        {

        // With 0.0.0.0 STUN server address, STUN is not used.

        // With this configuration CRLF bursts are sent

        // to keep the possible firewall hole open.

		__ASSERT_ALWAYS(aConfig->CRLFRefreshEnabledToProxyValue() ==

        				CNATTraversalConfig::EEnabled,

                        User::Leave(KErrArgument));

        }

    else

        {

        TBool stunServerConfigured = ETrue;

        TPtrC8 stunServerPtr(aConfig->STUNServer());

        if (stunServerPtr.Length() == 0)

            {

            stunServerPtr.Set(aConfig->Domain());

            stunServerConfigured = EFalse;

            }

        iSTUNClient = CSTUNClient::NewL(aConfig->STUNRetransmitTimer(),

                                        stunServerPtr,

                                        aConfig->STUNServerPort(),

                                        KStun,

                                        aSocketServ,

                                        aConnection,

                                        iDeltaTimer,

                                        aObserver,

                                        ETrue,

                                        !stunServerConfigured);

        if (aConfig->Username().Length() && aConfig->Password().Length())

            {

            iSTUNClient->SetCredentialsL(aConfig->Username(),

                                         aConfig->Password());

            }

        }

    // transfer the ownership only after calling all the leaving functions

    iConfig = aConfig;

    }

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

// CNATTraversalSession::~CNATTraversalSession

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

//

CNATTraversalSession::~CNATTraversalSession()

    {

    delete iSTUNClient;

    delete iConfig;

    iBindings.ResetAndDestroy();

    }

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

// CNATTraversalSession::HasSTUNClient

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

//

TBool CNATTraversalSession::HasSTUNClient(const CSTUNClient& aClient) const

    {

    return (iSTUNClient == &aClient);

    }

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

// CNATTraversalSession::Domain

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

//

const TDesC8& CNATTraversalSession::Domain() const

    {

    return iConfig->Domain();

    }

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

// CNATTraversalSession::IapId

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

//

TUint32 CNATTraversalSession::IapId() const

    {

    return iConfig->IapId();

    }

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

// CNATTraversalSession::UpdateNextHop

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

//

void CNATTraversalSession::UpdateNextHop(const TInetAddr& aNextHopAddr)

    {

    iNextHopAddr = aNextHopAddr;

    }

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

// CNATTraversalSession::HasBindings

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

//

TBool CNATTraversalSession::HasBindings() const

    {

    return (iBindings.Count() > 0);

    }

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

// CNATTraversalSession::HasBinding

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

//

TBool CNATTraversalSession::HasBinding(

    const MSIPNATBindingObserver* aObserver) const

    {

    return (FindBindingIndex(aObserver) >= 0);

    }

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

// CNATTraversalSession::InitCompletedL

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

//

void CNATTraversalSession::InitCompletedL()

    {

    NATTRAVERSAL_LOG("CNATTraversalSession::InitCompletedL")

    __ASSERT_ALWAYS(iSTUNClient, User::Leave(KErrCorrupt));

    iConfig->SetSharedSecretNotSupportedL(!iSTUNClient->SharedSecretObtained());

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

        {

        CNATBinding* bindingHolder = iBindings[i];

        CSTUNBinding* stunBinding =

            CSTUNBinding::NewL(*iSTUNClient,bindingHolder->STUNSocket());

        bindingHolder->SetBinding(stunBinding);

        bindingHolder->SendSTUNRequestL();

        }

    }

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

// CNATTraversalSession::InitFailed

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

//

void CNATTraversalSession::InitFailed(TInt aError)

    {

    NATTRAVERSAL_LOG("CNATTraversalSession::InitFailedL")

    TRAP_IGNORE(iConfig->SetBindingRequestFailedL(ETrue))

    for (TInt i=iBindings.Count()-1; i>=0; i--)

        {

        iBindings[i]->SetBindingFailed(aError);

        }

    }

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

// CNATTraversalSession::AddressResolvedL

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

//

TBool CNATTraversalSession::AddressResolvedL(const CBinding& aBinding)

    {

    NATTRAVERSAL_ADDRLOG("CNATTraversalSession::AddressResolvedL",

        aBinding.PublicAddr())

    TBool found = EFalse;

    for (TInt i=iBindings.Count()-1; i>=0 && !found; i--)

        {

        CNATBinding* bindingHolder = iBindings[i];

        if (bindingHolder->Binding() == &aBinding)

            {

            found = ETrue;

            TBool publicAddrChanged =

                bindingHolder->SetPublicAddr(aBinding.PublicAddr());

            if (publicAddrChanged)

                {

                // Existing public address has changed -> flow failure

                iBindings.Remove(i);

                bindingHolder->NATBindingObserver().FlowFailure(KErrGeneral);

                delete bindingHolder;

                }

            else

                {

                bindingHolder->ContinueRefreshing();

                }

            }

        }

    return found;

    }

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

// CNATTraversalSession::BindingFailed

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

//

TBool CNATTraversalSession::BindingFailed(

    const CBinding& aBinding,

    TInt aError)

    {

    TBool found = EFalse;

    for (TInt i=iBindings.Count()-1; i>=0 && !found; i--)

        {

        CNATBinding* bindingHolder = iBindings[i];

        if (bindingHolder->Binding() == &aBinding)

            {

            found = ETrue;

            TRAP_IGNORE(iConfig->SetBindingRequestFailedL(ETrue))

            bindingHolder->SetBindingFailed(aError);

            }

        }

    return found;

    }

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

// CNATTraversalSession::CreateNATBindingL

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

//

CNATBinding& CNATTraversalSession::CreateNATBindingL(

    TUint32 aRequestId,

    RSocket& aSocket,

    MSIPNATBindingObserver& aBindingObserver,

    MSIPNATTraversalRequestObserver& aRequestObserver,

    TBool& aAsyncCallInitiated)

    {

    aAsyncCallInitiated = EFalse;

    // Initialize binding's public address with the local address

    CNATBinding* bindingHolder =

        CNATBinding::NewLC(aRequestId,aSocket,iLocalAddr,

                           aRequestObserver,aBindingObserver,

                           iSocketManager);

    if (iSTUNClient)

        {

        // STUN used, not only CRLF-refreshes.

        if (iSTUNClient->IsInitialized())

            {

            if (!iConfig->BindingRequestFailed())

                {

                CSTUNBinding* stunBinding =

                    CSTUNBinding::NewL(

                        *iSTUNClient,bindingHolder->STUNSocket());

                bindingHolder->SetBinding(stunBinding);

                bindingHolder->SendSTUNRequestL();

                aAsyncCallInitiated = ETrue;

                }

            }

        else

            {

            // STUN Client is not initialized.

            aAsyncCallInitiated = (!iConfig->BindingRequestFailed());

            }

        }

    iBindings.AppendL(bindingHolder);

    CleanupStack::Pop(bindingHolder);

    return *bindingHolder;

    }

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

// CNATTraversalSession::RefreshNATBindingL

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

//

void CNATTraversalSession::RefreshNATBindingL(

    RSocket& aSocket,

    const MSIPNATBindingObserver* aBindingObserver,

    TBool& aMaintainPersistentConnection,

    TBool& aHandled)

    {

    aMaintainPersistentConnection = EFalse;

    aHandled = EFalse;

    TInt index = FindBindingIndex(aBindingObserver);

    if (index >= 0)

        {

        CNATBinding* binding = iBindings[index];

        if (!binding->Refresher() &&

            (IsBehindNAT(*binding) ||

             iConfig->CRLFRefreshEnabledToProxy(Protocol(aSocket))))

            {

            CreateRefresherL(*binding,aSocket,aMaintainPersistentConnection);

            }

        aMaintainPersistentConnection = binding->PersistentConnectionRequired();

        aHandled = ETrue;

        }

    }

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

// CNATTraversalSession::RefreshNATBindingL

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

//

void CNATTraversalSession::RefreshNATBindingL(

    CSecureSocket& aSecureSocket,

    const MSIPNATBindingObserver* aBindingObserver,

    TBool& aMaintainPersistentConnection,

    TBool& aHandled)

    {

    aMaintainPersistentConnection = EFalse;

    aHandled = EFalse;

    TInt index = FindBindingIndex(aBindingObserver);

    if (index >= 0)

        {

        CNATBinding* binding = iBindings[index];

        if (!binding->Refresher() &&

			(IsBehindNAT(*binding) ||

			 iConfig->CRLFRefreshEnabledToProxy(KProtocolInetTcp)))

            {

            CTlsCRLFSender* sender =

                new(ELeave)CTlsCRLFSender(aSecureSocket,*binding);

            CleanupStack::PushL(sender);

            CNATBindingRefresher* refresher =

                new(ELeave)CNATBindingCRLFRefresher(

                    iDeltaTimer,

                    iConfig->TCPRefreshInterval(),

                    *binding,

                    sender);

            CleanupStack::Pop(sender);

            binding->SetRefresher(refresher);

            }

        aMaintainPersistentConnection = binding->PersistentConnectionRequired();

        aHandled = ETrue;

        }

    }

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

// CNATTraversalSession::SocketIdle

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

//

void CNATTraversalSession::SocketIdle(

    TBool aIdle,

    RSocket& aSocket)

    {

    SocketIdleImpl(aIdle,aSocket);

    }

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

// CNATTraversalSession::SocketIdle

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

//

void CNATTraversalSession::SocketIdle(

    TBool aIdle,

    CSecureSocket& aSocket)

    {

    SocketIdleImpl(aIdle,aSocket);

    }

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

// CNATTraversalSession::DataReceivedL

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

//

void CNATTraversalSession::DataReceivedL(

    const TDesC8& aData,

    const RSocket& aSocket,

    TBool& aHandled)

    {

    for (TInt i=0; i<iBindings.Count() && !aHandled; i++)

        {

        iBindings[i]->HandleDataL(aData,aSocket,aHandled);

        }

    }

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

// CNATTraversalSession::RemoveBinding

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

//

TBool CNATTraversalSession::RemoveBinding(TUint32 aRequestId)

    {

    TBool found = EFalse;

    for (TInt i=0; i<iBindings.Count() && !found; i++)

        {

        CNATBinding* binding = iBindings[i];

        if (binding->InitialRequestId() == aRequestId)

            {

            iBindings.Remove(i);

            delete binding;

            found = ETrue;

            }

        }

    return found;

    }

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

// CNATTraversalSession::RemoveBinding

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

//

TBool CNATTraversalSession::RemoveBinding(

    const MSIPNATBindingObserver& aObserver)

    {

    TBool found = EFalse;

    TInt index = FindBindingIndex(&aObserver);

    if (index >= 0)

        {

        CNATBinding* binding = iBindings[index];

        iBindings.Remove(index);

        delete binding;

        found = ETrue;

        }

    return found;

    }

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

// CNATTraversalSession::DetachConfig

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

//

void CNATTraversalSession::DetachConfig()

    {

    iConfig = NULL;

    }

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

// CNATTraversalSession::Protocol

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

//

TUint CNATTraversalSession::Protocol(RSocket& aSocket) const

    {

    TProtocolDesc proto;

    aSocket.Info(proto);

    return proto.iProtocol;

    }

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

// CNATTraversalSession::RefreshInterval

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

//

TInt CNATTraversalSession::RefreshInterval(TUint aProtocol) const

    {

    TInt interval = 0;

    if (aProtocol == KProtocolInetTcp)

        {

        interval = iConfig->TCPRefreshInterval();