/** @file

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

*

*/

#include "upnpipaddressutils.h"

#include "upnpipeventnotifier.h"

#include "upnpconninterfacewatcher.h"

#include "upnpsettings.h"

#define KLogFile _L("UPnPConnManager.txt")

#include "upnpcustomlog.h"

using namespace UpnpIpAddressUtil;

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

// CUpnpConnInterfaceWatcher::NewL

//

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

//

CUpnpConnInterfaceWatcher* CUpnpConnInterfaceWatcher::NewL(

    MUpnpConnInterfaceWatcherObserver& aIfObserver, 

    RSocketServ& aSockServ,

    RConnection &aConnection )

    {

    CUpnpConnInterfaceWatcher* self = new (ELeave) CUpnpConnInterfaceWatcher( 

                                            aIfObserver, aSockServ, aConnection );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpConnInterfaceWatcher::CUpnpConnInterfaceWatcher

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUpnpConnInterfaceWatcher::CUpnpConnInterfaceWatcher(

    MUpnpConnInterfaceWatcherObserver& aIfObserver, 

    RSocketServ& aSockServ,

    RConnection &aConnection ) 

    : CActive( CActive::EPriorityStandard ),

      iIfObserver( aIfObserver ),

      iSockServ( aSockServ ),

      iConnection( aConnection )

    {

    }

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

// CUpnpConnInterfaceWatcher::~CUpnpConnInterfaceWatcher

// Destructor.

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

//

CUpnpConnInterfaceWatcher::~CUpnpConnInterfaceWatcher()

    {

    Cancel();

    delete iIPEvent;

    }

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

// CUpnpConnInterfaceWatcher::ConstructL

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

//

void CUpnpConnInterfaceWatcher::ConstructL()

    {

    LOG_FUNC_NAME;

    CActiveScheduler::Add( this );

    }

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

// CUpnpConnInterfaceWatcher::SubscribeForConnectionServiceChangeNotifications

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

//

void CUpnpConnInterfaceWatcher::SubscribeForConnectionServiceChangeNotifications()

    {

    if ( !IsActive() )

        {

        iConnection.ServiceChangeNotification( iNewISPId, iNewServiceType, iStatus );

        SetActive();

        }

    }

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

// CUpnpConnInterfaceWatcher::CancelSubscriptionForConnectionServiceChangeNotifications

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

//

void CUpnpConnInterfaceWatcher::CancelSubscriptionForConnectionServiceChangeNotifications()

    {

    Cancel();

    }

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

// CUpnpConnInterfaceWatcher::ListenAddressChangeL

// Creates and subscribes to CUpnpIPEventNotifier instance

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

//  

void CUpnpConnInterfaceWatcher::ListenAddressChangeL( TUint aIapId )

    {

    LOG_FUNC_NAME;

    iIapId = aIapId;

    LOGS1("ListenAddressChangeL: Given IAP: %d",iIapId);

    // get local IP                

    TInt interfaceIndex; // interface index used for subscribing for IP event

    SetLocalAddress( LocalIpAddress( interfaceIndex ) );

    delete iIPEvent;

    iIPEvent = NULL;

#ifdef _DEBUG

    LOGS1( "ListenAddressChangeL: interfaceIndex: %d", interfaceIndex );

    TBuf<50> buf;

    iLocalIpAddress.Output( buf );

    LOGS1( "ListenAddressChangeL: IP Addr: %S", &buf );

#endif //_DEBUG

    iIPEvent = CUpnpIPEventNotifier::NewL( interfaceIndex );

    iIPEvent->Subscribe( this );

    }

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

// CUpnpConnInterfaceWatcher::LocalAddress

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

//  

const TInetAddr& CUpnpConnInterfaceWatcher::LocalAddress()

    {

    return iLocalIpAddress;

    }

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

// CUpnpConnInterfaceWatcher::SetLocalAddress

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

//

void CUpnpConnInterfaceWatcher::SetLocalAddress( const TInetAddr& aAddress )

    {

    iLocalIpAddress.SetAddress( aAddress.Address() );

    }

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

// CUpnpConnInterfaceWatcher::IPEventOccursL

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

//

void CUpnpConnInterfaceWatcher::IPEventOccursL()

    {            

    TInt index;

    TInetAddr ip = LocalIpAddress( index );

#ifdef _DEBUG

    TBuf<KMaxName> address;

    ip.Output(address);       

    LOGS1H( iHandle, "MH IPEvent: %S", &address );

    RDebug::Print(_L("CUpnpConnInterfaceWatcher *** IPEventOccursL *** IP Address: %S"), &address );

#endif //_DEBUG

    if ( ip.Address() == 0 )

        {

        return;

        }

    if ( ip.Address() != LocalAddress().Address() )

        {       

        SetLocalAddress( ip );

        iIfObserver.InterfaceAddressChange( iLocalIpAddress );

        }    

    }

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

// CUpnpConnInterfaceWatcher::RunL

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

//

void CUpnpConnInterfaceWatcher::RunL()

    {

    if ( iStatus.Int() == KErrCancel )

        {

        iIfObserver.WlanNetworkLost();

        }

    else if ( iStatus.Int() >= KErrNone )

        {

        SubscribeForConnectionServiceChangeNotifications();

        }

    }

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

// CUpnpConnInterfaceWatcher::DoCancel

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

//

void CUpnpConnInterfaceWatcher::DoCancel()

    {

    iConnection.CancelServiceChangeNotification();

    }

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

// CUpnpConnInterfaceWatcher::RunError

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

//

TInt CUpnpConnInterfaceWatcher::RunError( TInt /*aError*/ )

    {

    LOG_FUNC_NAME;

    return KErrNone;

    }

TInetAddr CUpnpConnInterfaceWatcher::LocalIpAddress(TInt& aInterfaceIndex)

    {

    LOG_FUNC_NAME;

    RSocket socket;

    TInt err;

    TInt index; 

    TInt autoIfIndex = 0;

    TBool autoIpFound = EFalse;

    TBool ipFound = EFalse;

    TInetAddr localIpAddress;        

    TInetAddr autoIpAddress;

    TInt ret= socket.Open( iSockServ, KAfInet, KSockDatagram, KProtocolInetUdp);

    if ( KErrNone == ret )

          {

          err = socket.SetOpt( KSoInetEnumInterfaces, KSolInetIfCtrl );

          if ( err == KErrNone )

                {

                TPckgBuf<TSoInetInterfaceInfo> info;

                err = socket.GetOpt( KSoInetNextInterface, KSolInetIfCtrl, info );

                while ( err == KErrNone )

                    {

                    TPckgBuf<TSoInetIfQuery> query;

                    query().iName = info().iName;

                    err = socket.GetOpt( KSoInetIfQueryByName, KSolInetIfQuery, query );

                    if ( err == KErrNone )

                        {

                        index = query().iIndex;

                          //Address should be IPv4, not 0.0.0.0 & not loopback.

                          if ((info().iAddress.Address() != 0) && !info().iAddress.IsUnspecified() && !info().iAddress.IsLoopback() && query().iZone[1] == iIapId)

                            {

                        #ifdef _DEBUG

                             LOGS1( "LocalIpAddress: IAP is matched with %d",query().iZone[1] );

                             TBuf<50> buf;

                             info().iAddress.Output( buf );

                             LOGS1( "LocalIpAddress: info().iAddress: %S", &buf );

                        #endif

                             if ( info().iAddress.IsLinkLocal() )

                                 {

                                 autoIpFound = ETrue;

                                 autoIpAddress = info().iAddress;

                                 autoIpAddress.ConvertToV4();

                                 autoIfIndex = index;

                                 LOGS("LocalIpAddress: IP is Matched with AutoIP");

                            #ifdef _DEBUG

                                 TBuf<50> buf;

                                 autoIpAddress.Output( buf );

                                 LOGS1( "LocalIpAddress: Auto IP Addr: %S", &buf );

                            #endif

                                 }

                             // Other than auto IP

                             else

                                 {

                                 ipFound = ETrue;

                                 localIpAddress = info().iAddress;

                                 // we're using ipv4 addresses

                                 localIpAddress.ConvertToV4();

                                 aInterfaceIndex = index;

                                 LOGS("LocalIpAddress: IP is Matched with DHCP IP");

                            #ifdef _DEBUG

                                 TBuf<50> buf;

                                 localIpAddress.Output( buf );

                                 LOGS1( "LocalIpAddress: DHCP IP Addr: %S", &buf );

                            #endif

                                 }

                            }

                        }

                    err = socket.GetOpt( KSoInetNextInterface, KSolInetIfCtrl, info );

                    }

                }

          }

    socket.Close();

    if ( !ipFound && autoIpFound )

        {

        localIpAddress = autoIpAddress;

        aInterfaceIndex = autoIfIndex;

        }

#ifdef _DEBUG

    TBuf<50> buf;

    localIpAddress.Output( buf );

    LOGS1( "LocalIpAddress: IP Addr: %S", &buf );

#endif

    return localIpAddress;  

    }

//End of file