/*

* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Server class of wlan engine

*

*/

/*

*/

#include <e32def.h>

#include <e32std.h>

#include <featmgr.h>

#include <in_sock.h>

#include <bldvariant.hrh> // for feature definitions

#include "wlmserver.h"

#include "wlmdriverif.h"

#include "wlmsession.h"

#include "wlanconversionutil.h"

#include "core_server_factory.h"

#include "core_tools.h"

#include "core_type_list.h"

#include "wlaneapolclient.h"

#include "wlangenericplugin.h"

#include "wlanssidlistdb.h"

#include "wlandevicesettingsinternalcrkeys.h"

#include "wlanbgscan.h"

#include "wlantimerservices.h"

#include "am_debug.h"

/** Panic codes for WlanEngine */

const TInt KWlmPanicCleanupStackCreationFailed  = 1;

const TInt KWlmPanicOpenSemaforeFailed          = 2;

const TInt KWlmPanicCreationOfSchedulerFailed   = 3;

/** Panic category of WlanEngine */

_LIT( KWlmModuleName, "WLANSRV" );

/** Constants for sanity checks */

const i32_t MAX_RCP_BOUNDARY = 255;

const i32_t MAX_HYSTERESIS = 255;

const u8_t MAX_USER_PRIORITY = 7; 

/** The number of hours after which the domain information expires. */

const TInt KWlmDomainInfoExpire = 5;

/** Operator MCC codes for North America, Canada, Taiwan, Brazil, Argentina, Mexico and Colombia. */

const TUint KWlmOperatorMccNATable[] = { 302, 310, 311, 312, 313, 314, 315, 316, 332, 466, 724, 722, 334, 732 };

/** The amount of operator MCC codes for North America, Canada, Taiwan, Brazil, Argentina, Mexico and Colombia. */

const TUint KWlmOperatorMccNATableLength = 14;

/** AP country information codes for North America, Canada, Taiwan, Brazil, Argentina, Mexico and Colombia

    are defined in core_types.h. */

/** Timestamp is stored in CenRep in minutes, constant for converterting this to microseconds */

const TUint KWlmTimestampInCenrep = 60000000; 

/** WLAN region values in CenRep */

const TInt KWlmRegionUnknown   = 0;

const TInt KWlmRegionETSI      = 1;

const TInt KWlmRegionFCC       = 2;

/** Valid range for cache lifetime in scan requests (in seconds). */

const TInt KWlmMaxScanCacheLifetime      = 60;

const TInt KWlmMinScanCacheLifetime      = 0;

const TInt KWlmDefaultScanCacheLifetime  = -1;

/** Valid range for maximum scan delay in scan requests (in seconds). */

const TUint KWlmMaxScanDelay             = 1200;

/** Infinite scan delay in GetAvailableIaps and GetScanResult. */

const TUint KWlmInfiniteScanDelay        = 0xFFFFFFFF;

/** Granularity for WLAN SSID lists. */

const TUint KWlanSsidListGranularity = 100;

/** Bitmask of WLAN features enabled at compile-time. */

const TUint KWlanStaticFeatures =

/** Multiplier for converting seconds into microseconds */

const TUint KWlanSecsToMicrosecsMultiplier( 1000000 );

/** Minimum value for aggressive background scan interval, in seconds */

const TUint KWlanAggressiveBgScanMinInterval( 1 );

/** Maximum value for aggressive background scan interval, in seconds */

const TUint KWlanAggressiveBgScanMaxInterval( 120 );

/** Multiplier for deciding aggressive scan mode duration from set interval */

const TUint KWlanAggressiveBgScanDurationMultiplier( 6 );

/** Interval (in seconds) used for aggressive background scanning after

    unintentional link break. */

const TUint32 KWlanLinkBreakRecoveryInterval( 10 );

/** How long (in microseconds) aggressive background scanning is performed

    after unintentional link break. */

const TUint32 KWlanLinkBreakRecoveryDuration( 55000000 );  // 55 seconds

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

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

// CWlmServer::CWlmServer

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

// might leave.

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

//

CWlmServer::CWlmServer() :

    CServer2( CActive::EPriorityStandard ),

    iCoreServer( NULL ),

    iDriverIf( NULL ),

    iSupportedFeatures( KWlanStaticFeatures ),

    iScanSchedulingTimer( NULL ),

    iCache( NULL ),

    iConfiguredCacheLifetime( 0 ),

    iPlatform( NULL ),

    iConnectionState( EWlanStateNotConnected ),

    iPrevConnectionState( EWlanStateNotConnected ),

    iIsRoaming( EFalse ),

    iPrevRcpiValue( 0 ),

    iRegion( EFCC ),

    iTimeofDomainQuery( 0 ),

    iClientSessionCount( 0 ),

    iRequestIdCounter( KWlanExtCmdBase ),

    iSessionIdCounter( 0 ),

    iCoreAsynchCb( NULL ),

    iCoreAsynchCbId( 0 ),

    iCoreAsynchCbStatus( core_error_ok ),

    iIsStartupComplete( EFalse ),

    iEapolClient( NULL ),

    iEapolHandler( NULL ),

    iScanSchedulingTimerExpiration( 0 ),

    iRequestTriggeringScanning( 0 ),

    iCoreHandlingScanRequest( EFalse ),

    iPowerSaveMode( EWlanPowerSaveAutomatic ),

    iPowerSaveEnabled( EFalse ),

    iSsidListDb( NULL ),

    iBgScanProvider( NULL ),

    iTimerServices( NULL ),

    iAggressiveScanningAfterLinkLoss( EFalse )

    {

    }

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

// CWlmServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWlmServer::ConstructL()

    {

    DEBUG( "CWlmServer::ConstructL()" );

    User::LeaveIfError( User::RenameThread( KWLMDataServerName ) );

    StartL( KWLMDataServerName );    

    // Consult FeatureManager whether startup is allowed

    FeatureManager::InitializeLibL();

    if( !FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        DEBUG("ERROR: FeatureManager forbids starting of WlanServer");

        FeatureManager::UnInitializeLib();        

        User::Leave( KErrNotSupported );

        }

    if( FeatureManager::FeatureSupported( KFeatureIdFfWlanWapi ) )

        {

        }

    DEBUG1( "CWlmServer::ConstructL() - supported WLAN features: 0x%08X",

        iSupportedFeatures );

    FeatureManager::UnInitializeLib();

    // Create Driver Interface

    iDriverIf = CWlmDriverIf::NewL();

    // Get Mac Address

    TMacAddress mac( KZeroMacAddr );

    iDriverIf->GetMacAddress( mac );

    // Test its authenticity

    // If failure -> not starting the server

    const TMacAddress KDeadBeefMacAddr = {{ 0x00, 0xE0, 0xDE, 0xAD, 0xBE, 0xEF }};

    if( mac == KZeroMacAddr || mac == KDeadBeefMacAddr )

        {

        DEBUG("ERROR: MAC Address not acceptable -> Forbidden to start WlanServer");

        User::Leave( KErrNotSupported );

        }

    core_mac_address_s core_mac( ZERO_MAC_ADDR );

    TWlanConversionUtil::ConvertMacAddress( core_mac, mac );

    // Get Device Settings

    CWlanDeviceSettings::SWlanDeviceSettings deviceSettings;

    GetWlanSettingsL( deviceSettings );

    SetCachedRegion(deviceSettings.region, deviceSettings.regionTimestamp);    

    core_device_settings_s coreSettings; // core needs the settings here

    TWlanConversionUtil::ConvertDeviceSettings( coreSettings, deviceSettings );

    // Create core server    

    User::LeaveIfNull( iCoreServer = core_server_factory_c::instance(

        *this,

        *iDriverIf,

        coreSettings,

        core_mac,

    iCoreServer->disable_wlan( KWlanIntCmdDisableWlan );

    // Create scan timer

    DEBUG( "CWlmServer::ConstructL() - create backgroundscan timer" );

    iScanSchedulingTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    // Create scan cache

    iCache = CWlanScanResultCache::NewL();

    iConfiguredCacheLifetime = deviceSettings.scanExpirationTimer;

    // Create a callback for asynchronous core requests

    TCallBack callback( HandleCoreAsynchCb, this );

    iCoreAsynchCb = new (ELeave) CAsyncCallBack(

        callback, CActive::EPriorityStandard );

    // Create SSID list storage.

    iSsidListDb = CWlanSsidListDb::NewL();

    iTimerServices = CWlanTimerServices::NewL();

    iBgScanProvider = CWlanBgScan::NewL( static_cast<MWlanScanResultProvider&>( *this ), *iTimerServices );

    // Initialize Platform interface and publish mac address

    iPlatform = CWlmPlatform::NewL( *this );

    iPlatform->Initialize();

    TInt err = iPlatform->PublishMacAddress( mac );

    if( err )

        {

        DEBUG1( "ERROR publishing MAC address: %d", err );

        }    

    iGenericWlanPlugin.StartPlugins();

    DEBUG( "CWlmServer::ConstructL() - done" );    

    }

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

// CWlmServer::NewL

// Two-phased constructor.

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

//

EXPORT_C CWlmServer* CWlmServer::NewL()

    {

    CWlmServer* self = new( ELeave ) CWlmServer;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWlmServer::~CWlmServer

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

//

CWlmServer::~CWlmServer()

    {

    // Close all open sessions

    CWlmSession* session = NULL;

    iSessionIter.SetToFirst();

    while( (session = static_cast<CWlmSession*>(iSessionIter++)) != NULL )

        {

        delete session;

        }

    iGenericWlanPlugin.StopPlugins();

    delete iCoreServer;

    delete iDriverIf;

    iNotificationArray.Close();

    delete iCache;

    delete iPlatform;

    iRequestMap.Close();

    delete iCoreAsynchCb;

    delete iScanSchedulingTimer;

    delete iSsidListDb;

    iEapolHandler = NULL;

    }

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

// CWlmServer::StartServerThread

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

//

EXPORT_C TInt CWlmServer::StartServerThread()

    {

    DEBUG( "CWlmServer::StartServerThread()" );

    __UHEAP_MARK;

    // Create cleanup stack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    __ASSERT_ALWAYS( 

        cleanup, 

        User::Panic( KWlmModuleName, KWlmPanicCleanupStackCreationFailed ) 

        );

    // Open handle to semaphore

    RSemaphore started;

    TInt err = started.OpenGlobal( KWLMServerSemaphore, EOwnerProcess );

    __ASSERT_ALWAYS(

        err == KErrNone, 

        User::Panic( KWlmModuleName, KWlmPanicOpenSemaforeFailed )

        );

    // Create active scheduler   

    CWlmServer* server = NULL;

    CActiveScheduler* scheduler = new CActiveScheduler();

    if ( scheduler )

        {

        // Install scheduler

        CActiveScheduler::Install( scheduler );

        // Create server

        TRAP( err, server = CWlmServer::NewL() );

        if ( err != KErrNone )

            {

            DEBUG1( "CWlmServer::StartServerThread() - NewL leaved with code %d", err );

            }

        }

    else

        {

        User::Panic( KWlmModuleName, KWlmPanicCreationOfSchedulerFailed );

        }

    // Signal calling process that we've started via semaphore

    started.Signal(); 

    started.Close();

    // Start the active Scheduler (if there are no errors)

    if ( err == KErrNone )

        {

        DEBUG( "CWlmServer::StartServerThread() - Starting scheduler..." );

        CActiveScheduler::Start();

        }

    // Note that CActiveScheduler::Start() will not return until the scheduler

    // is stopped in CWlmServer::SessionClosed(). This is because we don't

    // belong to an active object, so there's no RunL() to be called.

    // Delete all objects

    delete server;

    delete CActiveScheduler::Current();

    delete cleanup;

    // Clean up Ecom framework

    REComSession::FinalClose();

    __UHEAP_MARKEND;

    return err;

    }

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

// CWlmServer::GetWlanSettingsL

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

//

void CWlmServer::GetWlanSettingsL(

    CWlanDeviceSettings::SWlanDeviceSettings& aSettings )

    {

    DEBUG( "CWlmServer::GetWlanSettingsL()" );

    CWlanDeviceSettings* db = CWlanDeviceSettings::NewL();

    CleanupStack::PushL( db );    

    db->ReadL( aSettings );

    CleanupStack::PopAndDestroy( db );

    }

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

// CWlmServer::GetIapSettingsL

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

//

void CWlmServer::GetIapSettingsL(

    const TUint32 aLanServiceId,

    SWLANSettings& aWlanSettings,

    RArray<TWlanSecondarySsid>& aSecondaryList )

    {

    DEBUG( "CWlmServer::GetIapSettingsL()" );

    CWLanSettings* wlanset = new(ELeave) CWLanSettings;

    CleanupStack::PushL( wlanset );

    User::LeaveIfError( wlanset->Connect() );

    User::LeaveIfError(

        wlanset->GetWlanSettingsForService( aLanServiceId, aWlanSettings ) );

	User::LeaveIfError(

		wlanset->GetSecondarySsidsForService( aWlanSettings.Id, aSecondaryList ) );

    DEBUG3( "- connMode == %d, securityMode == %d, # of secondary SSIDs == %d",

        aWlanSettings.ConnectionMode,

        aWlanSettings.SecurityMode,

        aSecondaryList.Count() );

    wlanset->Disconnect();

    CleanupStack::PopAndDestroy( wlanset );

    }

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

// CWlmServer::NewSessionL

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

//

CSession2* CWlmServer::NewSessionL(

    const TVersion& /*aVersion*/,

    const RMessage2& /*aMessage*/ ) const

    {

    DEBUG( "CWlmServer::NewSessionL()" );

    CWlmSession* session =

        CWlmSession::NewL(

            const_cast<CWlmServer&>(*this) );

    return session;

    }

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

// CWlmServer::NotifyAdd

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

//

void CWlmServer::NotifyAdd(

    CNotificationBase& aNotification )

    {

    DEBUG( "CWlmServer::NotifyAdd()" );

    iNotificationArray.Insert( &aNotification, 0 );

    }

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

// CWlmServer::NotifyRemove

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

//

void CWlmServer::NotifyRemove(

    CNotificationBase& aNotification )

    {

    DEBUG( "CWlmServer::NotifyRemove()" );

    TInt index = iNotificationArray.Find( &aNotification );

    iNotificationArray.Remove( index );

    }

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

// CWlmServer::Connect

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

//

void CWlmServer::Connect(

    TUint aSessionId,

    const RMessage2& aMessage )

    {

    DEBUG( "CWlmServer::Connect()" );

    // Get WlanSettings and secondarySSID list

    // (lanServiceId specifies the table row in wlansettings)

    SWLANSettings iapData;

    RArray<TWlanSecondarySsid> secondarySsidList;

    TInt lanServiceId = aMessage.Int0();

    TRAPD( err, GetIapSettingsL( lanServiceId, iapData, secondarySsidList ) ) ;

    if( err != KErrNone )

        {

        DEBUG1( "CWlmServer::Connect() - GetIapSettingsL leaved with %d",

            err );

        secondarySsidList.Close();        

        aMessage.Complete( err );

        return;

        }

    DEBUG5( "CWlmServer::Connect() - SecurityMode: %u, WPAKeyLength: %u, WPAPreSharedKey: %u, EnableWpaPsk: %u, PresharedKeyFormat: %u",

        iapData.SecurityMode, iapData.WPAKeyLength, iapData.WPAPreSharedKey.Length(),

        iapData.EnableWpaPsk, iapData.PresharedKeyFormat );

    // Check whether WAPI is supported

    if( iapData.SecurityMode == Wapi &&

        {

        DEBUG( "CWlmServer::Connect() - WAPI is not supported" );

        secondarySsidList.Close();        

        aMessage.Complete( KErrNotSupported );

        return;        

        }

    // Get override setting from message parameter

    TWLMOverrideSettings override = { 0 };

    TPckg<TWLMOverrideSettings> inData( override );

    err = aMessage.Read( 1, inData );

    if( err )

        {

        secondarySsidList.Close();

        aMessage.Complete( err );

        return;

        }

    // Type conversion

    core_iap_data_s* coreIapData = new core_iap_data_s;

    if( !coreIapData )

        {

        secondarySsidList.Close();

        aMessage.Complete( KErrNoMemory );

        return;

        }

    // Find out whether IP address should be static or dhcp

    CLanSettings lanSettingsClient;

    err = lanSettingsClient.Connect();