/*

* Copyright (c) 2006 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:   Implementation of WLAN SSID discovery class

*

*/

//  EXTERNAL INCLUDES

#include <wlanmgmtclient.h>

#include <wlanmgmtcommon.h>

//  CLASS HEADER

#include "wsfwlanssiddiscovery.h"

//  INTERNAL INCLUDES

#include "wsflogger.h"

using namespace CMManager;

/**

* Management frame information element IDs.

* needed to determine SSID

* (from \S60\osext\wlan\wlanldd\wlan_common\umac_common\inc\802dot11.h)

*/

enum TWsf802Dot11InformationElementID

    {

    E802Dot11SsidIE                 = 0,

    E802Dot11SupportedRatesIE       = 1,

    E802Dot11FhParameterSetIE       = 2,

    E802Dot11DsParameterSetIE       = 3,

    E802Dot11CfParameterSetIE       = 4,

    E802Dot11TimIE                  = 5,

    E802Dot11IbssParameterSetIE     = 6,

    E802Dot11CountryIE              = 7,

    E802Dot11HoppingPatternParamIE  = 8,

    E802Dot11HoppingPatternTableIE  = 9,

    E802Dot11RequestIE              = 10,

    E802Dot11ChallengeTextIE        = 16,

    // Reserved for challenge text extension 17 - 31

    E802Dot11ErpInformationIE       = 42,

    E802Dot11ExtendedRatesIE        = 50,

    E802Dot11AironetIE              = 133,

    E802Dot11ApIpAddressIE          = 149,

    E802Dot11RsnIE                  = 221

    };

/**

* Bit masks for Capability Information field.

* (from \S60\osext\wlan\wlanldd\wlan_common\umac_common\inc\802dot11.h)

*/

enum TWsf802Dot11CapabilityBitMask

    {

    E802Dot11CapabilityEssMask          = 0x0001,

    E802Dot11CapabilityIbssMask         = 0x0002,

    E802Dot11CapabilityCfPollableMask   = 0x0004,

    E802Dot11CapabilityCfPollRequestMask= 0x0008,

    E802Dot11CapabilityPrivacyMask      = 0x0010,

    E802Dot11ShortPreambleMask          = 0x0020,

    E802Dot11PbccMask                   = 0x0040,      

    E802Dot11ChannelAgilityMask         = 0x0080

    };

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

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

// CWsfWlanSsidDiscovery::NewL

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

//

CWsfWlanSsidDiscovery* CWsfWlanSsidDiscovery::NewL()

    {

    CWsfWlanSsidDiscovery* self = new (ELeave) CWsfWlanSsidDiscovery();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfWlanSsidDiscovery::CWsfWlanSsidDiscovery

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

//

CWsfWlanSsidDiscovery::CWsfWlanSsidDiscovery(): CActive( EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CWsfWlanSsidDiscovery::ConstructL

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

//

void CWsfWlanSsidDiscovery::ConstructL()

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::ConstructL" );

#ifndef __WINS__

    iWlanMgmt = CWlanMgmtClient::NewL();

    iScanInfo = CWlanScanInfo::NewL();

#endif    

    }

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

// CWsfWlanSsidDiscovery::~CWsfWlanSsidDiscovery()

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

//

CWsfWlanSsidDiscovery::~CWsfWlanSsidDiscovery()

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::~CWsfWlanSsidDiscovery" );

    Cancel();

    delete iWlanMgmt;

    delete iScanInfo;    

    }

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

// CWsfWlanSsidDiscovery::DoCancel

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

//

void CWsfWlanSsidDiscovery::DoCancel()

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::DoCancel" );

#ifndef __WINS__    

    iWlanMgmt->CancelGetScanResults();

#endif    

    }

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

// CWsfWlanSsidDiscovery::AbortScanning

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

//

void CWsfWlanSsidDiscovery::AbortScanning()

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::AbortScanning" );

    if ( iWait.IsStarted() )

        {

        LOG_WRITE( "aborting..." );

        Cancel();

        iProgState = EAborted;

        iWait.AsyncStop();

        }    

    }

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

// CWsfWlanSsidDiscovery::RunL

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

//

void CWsfWlanSsidDiscovery::RunL()

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::RunL" );

    if ( iProgState == EScanning )

        {

        if ( !iStatus.Int() )

            // The list is ready 

            {

            LOG_WRITE( "No error" );

            iProgState = EDone;

            }

        else

            // something went wrong -> no coverage.

            {

            LOG_WRITE( "error" );

            }

        }

    // stop blocking

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    }

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

// CWsfWlanSsidDiscovery::ScanForSsidL

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

//

TBool CWsfWlanSsidDiscovery::ScanForSsidL( TWlanSsid& aEnteredSsid,

                                TBool aBroadcast,

                                CMManager::TWlanNetMode& aNetworkMode, 

                                CMManager::TWlanSecMode& aSecurityMode,

                                TBool& aUsesPsk )

    {

    LOG_ENTERFN( "CWsfWlanSsidDiscovery::ScanForSsidL" );

    if ( IsActive() )

        {

        return EFalse;

        }

    TBool found = EFalse;

#ifndef __WINS__

    iProgState = EScanning;

    if ( aBroadcast )

        {

        LOG_WRITE( "performing broadcast scan" );

        iWlanMgmt->GetScanResults( iStatus, *iScanInfo );

        }

    else

        {

        LOG_WRITE( "performing direct scan" );        

        iWlanMgmt->GetScanResults( aEnteredSsid, iStatus, *iScanInfo );

        }

    SetActive();

    iWait.Start();

    // now we have the results and might start to work on them...

    if ( iProgState == EDone )

        {

        LOG_WRITE( "iProgState = EDone" );

        //finished without error, work on the result...

        for ( iScanInfo->First(); !found && !iScanInfo->IsDone(); 

                                                          iScanInfo->Next() )

            {

            TUint8 ieLen( 0 );

            const TUint8* ieData;

            TInt ret = iScanInfo->InformationElement( E802Dot11SsidIE, ieLen, 

                                                     &ieData );

            User::LeaveIfError( ret );

            // get the ssid

            TWlanSsid ssid;

            ssid.Copy( ieData, ieLen );

            if ( !aEnteredSsid.Compare( ssid ) )

                {

                // SSID matched

                LOG_WRITE( "SSID matched, processing security settings" );

                found = ETrue;

                // adhoc or infrastructure

                aNetworkMode = ( iScanInfo->Capability() & 

                                 E802Dot11CapabilityEssMask ) ?

                                        EInfra : EAdhoc;

                // security mode

                TWlanConnectionSecurityMode connSec = 

                                                   iScanInfo->SecurityMode();

                // convert TWlanConnectionSecurityMode to 

                // CMManager::TWlanSecMode

                switch ( connSec )

                    {

                    case EWlanConnectionSecurityOpen:

                        {

                        aSecurityMode = EWlanSecModeOpen;

                        break;

                        }

                    case EWlanConnectionSecurityWep:

                        {

                        aSecurityMode = EWlanSecModeWep;

                        break;

                        }

                    case EWlanConnectionSecurity802d1x:

                        {

                        aSecurityMode = EWlanSecMode802_1x;

                        break;

                        }

                    case EWlanConnectionSecurityWpa:

                    case EWlanConnectionSecurityWpaPsk:

                        {

                        aSecurityMode = EWlanSecModeWpa;

                        break;

                        }

                    default:

                        {

                        }

                    }

                aUsesPsk = ( connSec == EWlanConnectionSecurityWpaPsk );

                } // if aEnteredSsid

            } // for

        }

    else if ( iProgState == EAborted )

        {

        LOG_WRITE( "iProgState = EAborted" );

        User::Leave( KErrCancel );

        }

    else

        {

        LOG_WRITEF( "iProgState = ???, iStatus = %d", iStatus.Int() );

        User::LeaveIfError( iStatus.Int() );

        }

#else // __WINS__

    // we don't like warnings

    aEnteredSsid, aBroadcast, aNetworkMode, aSecurityMode, aUsesPsk;

#endif // __WINS__

    return found;

    }