/*
* 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();
        }
    if (aProtocol == KProtocolInetUdp)
        {
        interval = iConfig->UDPRefreshInterval();
        }
    return interval;
    }

// -----------------------------------------------------------------------------
// CNATTraversalSession::FindBindingIndex
// -----------------------------------------------------------------------------
//
TInt CNATTraversalSession::FindBindingIndex(
    const MSIPNATBindingObserver* aBindingObserver) const
    {
    TInt index = KErrNotFound;
    for (TInt i=0; i < iBindings.Count() && index == KErrNotFound; i++)
        {
        CNATBinding* binding = iBindings[i];
        if (&(binding->NATBindingObserver()) == aBindingObserver)
            {
            index = i;
            }
        }
    return index;
    }

// -----------------------------------------------------------------------------
// CNATTraversalSession::CreateRefresherL
// -----------------------------------------------------------------------------
//
void CNATTraversalSession::CreateRefresherL(
    CNATBinding& aBinding,
    RSocket& aSocket,
    TBool& aMaintainPersistentConnection)
    {
    aMaintainPersistentConnection = EFalse;
    CNATBindingRefresher* refresher = NULL;
    TUint protocol = Protocol(aSocket);
    TInt refreshInterval = RefreshInterval(protocol);
    if (protocol == KProtocolInetTcp)
        {
        CTcpCRLFSender* sender =
            new(ELeave)CTcpCRLFSender(aSocket,aBinding);
        CleanupStack::PushL(sender);
        refresher = new(ELeave)CNATBindingCRLFRefresher(iDeltaTimer,
                                                        refreshInterval,
                                                        aBinding,
                                                        sender);
        CleanupStack::Pop(sender);
        aMaintainPersistentConnection = ETrue;
        }
    else if (protocol == KProtocolInetUdp)
        {
        if (IsBehindNAT(aBinding) && aBinding.AddressResolved())
            {
            // STUN has been succesfully used to detect a NAT
            if (iSTUNClient &&
                iNextHopAddr.Match(iSTUNClient->STUNServerAddrL()))
                {
                // Next hop has a STUN server -> refresh using STUN
                refresher =
                    new(ELeave)CNATBindingSTUNRefresher(iDeltaTimer,
                                                        refreshInterval,
                                                        aBinding,
                                                        aBinding);
                }
            else
                {
                // Refresh using STUN towards STUN server and
                // using CRLF towards the SIP proxy
                refresher = CNATBindingSTUNAndCRLFRefresher::NewL(
                    iDeltaTimer,refreshInterval,aBinding,
                    aBinding,aSocket,iNextHopAddr,iSocketManager);
                }
            }
        else
            {
            if (iConfig->CRLFRefreshEnabledToProxy(protocol))
                {
                CUdpCRLFSender* sender =
                    new(ELeave)CUdpCRLFSender(
                        aSocket,iNextHopAddr,aBinding,iSocketManager);
                CleanupStack::PushL(sender);
                refresher =
                    new(ELeave)CNATBindingCRLFRefresher(
                        iDeltaTimer,refreshInterval,aBinding,sender);
                CleanupStack::Pop(sender);
                }
            }
        }
    else
        {
        User::Leave(KErrNotSupported);
        }
    aBinding.SetRefresher(refresher);
    }

// -----------------------------------------------------------------------------
// CNATTraversalSession::SocketIdleImpl
// -----------------------------------------------------------------------------
//
template<class T> void CNATTraversalSession::SocketIdleImpl(
    TBool aIdle,
    T& aSocket)
    {
    for (TInt i=0; i<iBindings.Count(); i++)
        {
        CNATBindingRefresher* bindingRefresher = iBindings[i]->Refresher();
        if (bindingRefresher && bindingRefresher->HasSocket(aSocket))
            {
            bindingRefresher->SetRefresh(aIdle);
            }
        }
    }

// -----------------------------------------------------------------------------
// CNATTraversalSession::IsBehindNAT
// -----------------------------------------------------------------------------
//
TBool CNATTraversalSession::IsBehindNAT(const CNATBinding& aBinding) const
    {
    TBool natDetected = EFalse;
    if (aBinding.AddressResolved())
        {
        if (!aBinding.PublicAddr().Match(iLocalAddr))
            {
            natDetected = ETrue;
            }
        }
    else
        {
        if (IsPrivateAddress(iLocalAddr))
            {
            natDetected = ETrue;
            }
        }
    return natDetected;
    }

// -----------------------------------------------------------------------------
// CNATTraversalSession::IsPrivateAddress
// -----------------------------------------------------------------------------
//
TBool CNATTraversalSession::IsPrivateAddress(const TInetAddr& aAddr) const
    {
    TBool isPrivate = EFalse;
    if (aAddr.Family() == KAfInet)
        {
        // aAddr is IPv4 address, IPv6 addresses are always public
        TUint32 addr = aAddr.Address();
        if ((addr >= KPrivateRange1Low && addr <= KPrivateRange1High) ||
            (addr >= KPrivateRange2Low && addr <= KPrivateRange2High) ||
            (addr >= KPrivateRange3Low && addr <= KPrivateRange3High))
                {
                isPrivate = ETrue;
                }
        }
    return isPrivate;
    }