/*

* 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:  Address resolver utility class

*

*/

#include <wlaninternalpskeys.h>

#include <cmmanagerext.h>

#include <cmpluginwlandef.h>

#include "cipapputilsaddressresolver.h"

const TInt KWlanMacAddressPos = 2;

// ======== MEMBER FUNCTIONS ========

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

// Constructor

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

//

CIPAppUtilsAddressResolver::CIPAppUtilsAddressResolver()

    {

    }

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

// 2nd phase constructor

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

//

void CIPAppUtilsAddressResolver::ConstructL()

    {

    // Connect to Socket server.

    User::LeaveIfError( iSocketServer.Connect() );

    // Connect to Socket.

    User::LeaveIfError( iSocket.Open( iSocketServer,

                                      KAfInet,

                                      KSockStream,

                                      KProtocolInetTcp ) );

    }

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

// Constructor

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

//

EXPORT_C CIPAppUtilsAddressResolver* CIPAppUtilsAddressResolver::NewL()

    {

    CIPAppUtilsAddressResolver* self = CIPAppUtilsAddressResolver::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

EXPORT_C CIPAppUtilsAddressResolver* CIPAppUtilsAddressResolver::NewLC()

    {

    CIPAppUtilsAddressResolver* self = new( ELeave ) CIPAppUtilsAddressResolver;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CIPAppUtilsAddressResolver::~CIPAppUtilsAddressResolver()

    {

    iSocket.Close();

    iSocketServer.Close();

    }

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

// CIPAppUtilsAddressResolver::GetWlanMACAddress

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

//

EXPORT_C TInt CIPAppUtilsAddressResolver::GetWlanMACAddress (

    TDes8& aWlanMacAddress,

    const TDesC8& aByteFormat )

    {

    TBuf8<KPSWlanMacAddressLength> address;

    TInt retval = KErrNone;

    retval = RProperty::Get( 

        KPSUidWlan, 

        KPSWlanMacAddress, 

        address );

    if ( retval == KErrNone )

        {

        if ( aByteFormat.Length() == 0 )

            {

            //client wants raw data

            aWlanMacAddress.Copy( address );

            }

        else

            {

            for ( TInt counter = 0; counter < address.Length(); counter++ )

                {

                TUint16 a = (TUint16)address[ counter ];

                aWlanMacAddress.AppendNumFixedWidthUC( a, EHex, KWlanMacAddressPos );

                aWlanMacAddress.Append( aByteFormat );

                aWlanMacAddress.UpperCase();

                }

            // Delete the last format

            if ( aWlanMacAddress.Length() )

                {

                aWlanMacAddress.Delete( aWlanMacAddress.Length() - aByteFormat.Length(), aByteFormat.Length() );

                }

            }

        if ( aWlanMacAddress.Length() == 0 ) 

            {

            retval = KErrNotFound;

            }

        }

    return retval;

    }

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

// CIPAppUtilsAddressResolver::GetLocalIpAddressFromIap

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

//

EXPORT_C TInt CIPAppUtilsAddressResolver::GetLocalIpAddressFromIap( 

    TInetAddr& aLocalIpAddr,

    TUint32 aIapId )

    {

    TInt retval( KErrNotFound );

    TInt err = iSocket.SetOpt( KSoInetEnumInterfaces, KSolInetIfCtrl );

    if ( KErrNone == err )

        {

        TPckgBuf<TSoInetInterfaceInfo> info;

        err = iSocket.GetOpt( KSoInetNextInterface,

                KSolInetIfCtrl,info );

        while ( KErrNone == err && KErrNone != retval )

            {

            TPckgBuf<TSoInetIfQuery> query;

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

            err = iSocket.GetOpt( KSoInetIfQueryByName,

                    KSolInetIfQuery,query );

            if ( KErrNone == err )

                {

                retval = CheckAndSetAddr( 

                        aLocalIpAddr, (TInetAddr&)info().iAddress,

                        query().iZone[1], aIapId );

                err = iSocket.GetOpt( KSoInetNextInterface,

                        KSolInetIfCtrl,info );

                }

            }

        }

    if ( KErrNoMemory == err )

        {

        retval = err;

        }

    return retval;

    }

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

// CLocalAddrResolver::CheckAndSetAddr

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

//

TInt CIPAppUtilsAddressResolver::CheckAndSetAddr( 

    TInetAddr& aTarget,

    TInetAddr& aCandidate,

    TUint32 aCandidateIap,

    TUint32 aSpecifiedIap ) const

    {

    TInt retval = KErrNotFound;

    if ( !aCandidate.IsLinkLocal() &&

         !aCandidate.IsUnspecified() && 

         !aCandidate.IsLoopback() )

        {

        if ( aCandidate.IsV4Mapped())

            {

            aCandidate.ConvertToV4();

            }

        if ( aCandidateIap == aSpecifiedIap )

            {

            aTarget = aCandidate;

            aTarget.SetScope(0);

            retval = KErrNone;

            }

        }

    return retval;

    }                                         

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

// CIPAppUtilsAddressResolver::WlanSsidL

// Returns WLAN SSID based on given IAP id.

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

//

EXPORT_C void CIPAppUtilsAddressResolver::WlanSsidL(

    TUint32 aIapId, TDes& aWlanSsid )

    {

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    // Check that bearer is WLAN.

    if ( KUidWlanBearerType == 

        cmManager.GetConnectionMethodInfoIntL( 

            aIapId, CMManager::ECmBearerType ) )

        {

        RCmConnectionMethodExt connMethod = 

            cmManager.ConnectionMethodL( aIapId );

        CleanupClosePushL( connMethod );

        // Get SSID for WLAN.

        HBufC* wlanSsid = connMethod.GetStringAttributeL( 

            CMManager::EWlanSSID );

        aWlanSsid.Copy( *wlanSsid );

        delete wlanSsid;

        CleanupStack::PopAndDestroy( &connMethod );    

        }

    else

        {

        User::Leave( KErrNotFound ); // leave if bearer is not WLAN

        }

    CleanupStack::PopAndDestroy( &cmManager );

    }