/*

* Copyright (c) 2001-2009 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: Implements a state - machine like active object that controls Wi-Fi Protected Setup Process. 

*

*/

/*

*/

//SYSTEM INCLUDES

#include <wlanmgmtclient.h>

#include <wifiprotplugin.rsg>

#include <StringLoader.h>

#include <AknWaitDialog.h>

#include <cmpluginwlandef.h>

#include <commdb.h>

#include <WPASecuritySettingsUI.h>

#include <WEPSecuritySettingsUI.h>

#include <e32math.h>

#include <cmconnectionmethoddef.h>

#include <wlanerrorcodes.h>

#include <utf.h>

#include <AknIconArray.h>

#include <AknGlobalNote.h>

#include <AknSgcc.h>

#include <uikon/eiksrvui.h>

#include <AknsUtils.h>

#include <data_caging_path_literals.hrh>

#include <wifiprot.mbg>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <e32std.h>

//USER INCLUDES

#include "wifiprotlogger.h"

#include "wifiprotactiverunner.h"

#include "wifiprotconfirmationnotedlg.h"

#include "wifiprotselectnetworkdlg.h"

#include "wifiprotenterpindlg.h"

#include "wifiprotinitiateeasysetupdlg.h"

#include "featmgr.h"

// valid Wep key lengths, to check wep key format

// (wep key format depends on key length)

const TInt KConnUiUtilsWepLengthASCII5 = 5;

const TInt KConnUiUtilsWepLengthASCII13 = 13;

const TInt KConnUiUtilsWepLengthASCII29 = 29;

const TInt KConnUiUtilsWepLengthHEX10 = 10;

const TInt KConnUiUtilsWepLengthHEX26 = 26;

const TInt KConnUiUtilsWepLengthHEX58 = 58; 

#ifdef __WINS__

const TInt KNumberOfEmulatedAvailableNetworks = 2; 

const TInt KIndexOfFirstEmulatedAvailableNetwork = 0;

const TInt KIndexOfSecondEmulatedAvailableNetwork = 1;

#endif

/**

* Management frame information element IDs.

* needed to determine coverage

*/

enum T802Dot11InformationElementID

    {

    E802Dot11SsidIE                 = 0,

    E802Dot11SupportedRatesIE       = 1,

    E802Doi11FhParameterSetIE       = 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

    };

const TInt KArrayGranularity = 10; 

const TInt KIconsGranularity = 4;

_LIT( KWiFiFileIcons, "z:wifiprot.mbm" );

_LIT8( KEapWsc, "\xFE\x00\x37\x2A\x00\x00\x00\x01");

_LIT( KWiFiPanic, "Wi-Fi Protected Setup");

using namespace CMManager;

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

//

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

// CWiFiProtActiveRunner::NewL

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

//

CWiFiProtActiveRunner* CWiFiProtActiveRunner::NewL(

        CWiFiProtDlgsPlugin* aParent, TInt aPriority )

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::NewL" );

    CWiFiProtActiveRunner* self =

         new(ELeave) CWiFiProtActiveRunner( aParent, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::NewL" );

    return self;

    }

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

// CWiFiProtActiveRunner::~CWiFiProtActiveRunner

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

//

CWiFiProtActiveRunner::~CWiFiProtActiveRunner()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" );

    // Close notifier

    iNotifier.Close();

    Cancel();

    // If the cancel has been initiated by the client, temp IAP cannot be deleted until

    // after the RNotifier Cancel() call has returned (deadlock between MPM and CMM).

    // Therefore, temp IAP cleanup must be done later.

    if ( !iClientCancelled )

        {

        TRAP_IGNORE( DeleteTempIapL() ); //we can't do much if delete fails

        }

    delete iWlanMgmtEngine;

    // if cancelled from client, wait note may still be visible

    if ( iWaitDlg )

        {

        CLOG_WRITE( "iWaitDlg->SetCallback( NULL );" );

        iWaitDlg->SetCallback( NULL );

        CLOG_WRITE( "iWaitDlg->ProcessFinishedL( );" );

        TRAP_IGNORE( iWaitDlg->ProcessFinishedL() );

        delete iWaitDlg;

        }

    if ( iPinDlg )

        {

        delete iPinDlg;

        }

    TBool cleanupCms = EFalse;

    if ( iReturn == EWiFiCancel )

        {

        cleanupCms = ETrue;

        }

    for ( TInt i = 0; i < iCmArray.Count();i++ )

        {

        // if we are setting up a connection, we save the settings into

        // easy wlan iap (connection method), which we shouldn't ever delete!

        if ( ( !iIsConnectionNeeded ) && cleanupCms )

            {

            //we can't do much if delete fails

            TRAP_IGNORE( iCmArray[i]->DeleteL() );

            }

        iCmArray[i]->Close();

        delete iCmArray[i];

        iCmArray[i] = NULL;

        }

    iCmArray.ResetAndDestroy();

    iAvailableNetworks.Close();

    delete iIapParametersArray;

    delete iScanInfo;

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" );

    }

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

// CWiFiProtActiveRunner::StartProtectedSetupL

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

//

void CWiFiProtActiveRunner::StartProtectedSetupAsyncL (

                                            const TWlanSsid& aSSid,

                                            RArray<TUint32>& aUids,

                                            RCmManagerExt& aCmManagerToUse )

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" );

    iIsConnectionNeeded = EFalse;

    iUids = &aUids;

    iCmManagerExt = &aCmManagerToUse;    

    iSsid.Copy( aSSid );

    ShowInitialDialogL();

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" );

    }

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

// CWiFiProtActiveRunner::StartProtectedSetupConnL

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

//

void CWiFiProtActiveRunner::StartProtectedSetupConnL (

                                     const TWlanSsid& aSSid,

                                     TWlanProtectedSetupCredentialAttribute&

                                          aNetworkSettings,

                                     RCmManagerExt& aCmManagerToUse )

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" );

    iIsConnectionNeeded = ETrue;

    iNetworkSettings = &aNetworkSettings;

    iCmManagerExt = &aCmManagerToUse;    

    iSsid.Copy( aSSid );

    ShowInitialDialogL();

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" );

    }

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

// CWiFiProtActiveRunner::StartProtectedSetupL

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

//

WiFiProt::TWiFiReturn CWiFiProtActiveRunner::StartProtectedSetupL (

                                            const TWlanSsid& aSSid,

                                            RArray<TUint32>& aUids,

                                            RCmManagerExt& aCmManagerToUse )

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupL" );

    iSyncMode = ETrue;

    iIsConnectionNeeded = EFalse;

    iUids = &aUids;

    iCmManagerExt = &aCmManagerToUse;    

    iSsid.Copy( aSSid );

    ShowInitialDialogL();

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupL" );

    return iReturn;

    }

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

// CWiFiProtActiveRunner::CancelByClient()

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

//

void CWiFiProtActiveRunner::CancelByClient()

    {

    iClientCancelled = ETrue;

    Cancel();

    if ( iWaitDlg )

        {

        CLOG_WRITE( "Removing wait note( );" );

        iWaitDlg->SetCallback( NULL );

        TRAPD(err, iWaitDlg->ProcessFinishedL());

        if (err)

            {

            CLOG_WRITE( "LEAVE: iWaitDlg->ProcessFinishedL" );

            }

        delete iWaitDlg;

        iWaitDlg = NULL;

        }

    }

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

// CWiFiProtActiveRunner::ShowInitialDialogL()

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

//

void CWiFiProtActiveRunner::ShowInitialDialogL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitialDialogL" );

    if ( IsActive() == EFalse ) 

        {

        // Check if offline mode is on:

        iInOfflineMode = EFalse;

        if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

               {

               TInt connAllowed;

               CRepository* repository = CRepository::NewLC( 

                                                           KCRUidCoreApplicationUIs );

               repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );

               CleanupStack::PopAndDestroy(repository);  // repository

               if ( connAllowed == 0 )

                   {

                   iInOfflineMode = ETrue;

                   }

               }

        if ( iInOfflineMode && iSyncMode )

            {

            // If in offline mode, query about offline mode first.

            iNextWiFiProtState = EWifiProtOfflineQuery;

            }

        else

            {

            // Else initiate easy setup.

            iNextWiFiProtState = EWiFiProtInitiateEasySetup;

            }

        iConfirmationDialog =

                     new ( ELeave ) CWiFiProtConfirmationNoteDlg( iStatus );

        iConfirmationDialog->ExecuteLD( R_WIFIPROT_CONFIGURE_AUTO_DIALOG );

        iORequest = EWiFiProtReqConfirmDialog;

        SetActive( );

        if ( iSyncMode )

            {

            CLOG_WRITE(  "CActiveSchedulerWait Started" );

            iWait.Start();

            CLOG_WRITE(  "CActiveSchedulerWait Returned" );

            }

        }// do nothing if already active

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitialDialogL" );

    }

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

// CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL()

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

//

void CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" );

    iDestroyInitDialogLater = EFalse;

    iNextWiFiProtState = EWiFiProtUsePinCode;

    //store it, but not own it

    iInitDialog = new ( ELeave ) CWiFiProtInitiateEasySetupDlg( iStatus ); 

    iInitDialog->PrepareLC( R_WIFIPROT_INITIATE_EASY_SETUP_DIALOG );

    _LIT( KLinkStartTag, "\n<AknMessageQuery Link>" );

    _LIT( KLinkEndTag, "</AknMessageQuery Link>" );

    HBufC *messageBase =

             StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_MSG_PBC );

    HBufC* linkString1 = StringLoader::LoadLC( 

                            R_QTN_NETW_CONSET_WPS_MSG_LINK_USE_PIN );

    TInt lenMsg = messageBase->Des().Length()+

                  linkString1->Des().Length()+

                  KLinkStartTag().Length()+

                  KLinkEndTag().Length();    

    HBufC* message = HBufC::NewLC( lenMsg );

    TPtr messagePtr = message->Des();

    messagePtr.Append( messageBase->Des() ); 

    messagePtr.Append( KLinkStartTag ); 

    messagePtr.Append( linkString1->Des() );

    messagePtr.Append( KLinkEndTag );    

    iInitDialog->SetMessageTextL( messagePtr );

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( linkString1 );

    CleanupStack::PopAndDestroy( messageBase );    

    TCallBack callBackLink( CWiFiProtActiveRunner::UsePinCodeLinkSelectedL,

                                                                     this );

    iInitDialog->SetLink( callBackLink  );    

    iInitDialog->RunLD();

    iORequest = EWiFiProtReqInitDialog;

    SetActive( );

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" );

    }

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

// CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL()

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

//

void CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" );

    iNextWiFiProtState = EWiFiProtStartingWaitDlg;

    TInt pin = 0;

    TTime t;

    t.HomeTime();

    TInt64 seed = t.Int64();

    do  {

         pin = Math::Rand( seed );

        }

        while ( pin <(10^(KMaxPINLength-2))

             || ( ((pin / 1000000) % 10) ) == 0 );

    //last digit is checksum, so we need 7 digits

    //and the first shouldn't be 0

    pin = pin % 10000000; 

    TInt checkSum = ComputeChecksum(pin);

    pin *= 10;

    pin += checkSum;

    _LIT(KPinFormat,"%d");

    iPIN.Format(KPinFormat, pin);

    CLOG_WRITE( "Enter pin code note" );

    HBufC* prompt =

     StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_INFO_ENTER_PIN_CODE, pin );

    CWiFiProtEnterPinDlg* pinDlg = new ( ELeave ) CWiFiProtEnterPinDlg( *this );

    CleanupStack::PushL(pinDlg);

    pinDlg->SetPromptL( *prompt );

    CleanupStack::Pop(pinDlg);

    CleanupStack::PopAndDestroy( prompt );

    iPinDlg = pinDlg;

    iPinDlg->ExecuteLD( R_WIFIPROT_ENTER_PIN_CODE_DIALOG );

    iPinQueryActive = ETrue;

    SetActive( );

    SetNextStateAndComplete( EWiFiProtConfiguring );

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" );

    }

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

// CWiFiProtActiveRunner::ShowWaitingDialogL()

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

//

void CWiFiProtActiveRunner::ShowWaitingDialogL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" );

    HBufC* text = StringLoader::LoadLC(

            R_QTN_NETW_CONSET_WAIT_WPS_CONFIGURING );

    iWaitDlg = new ( ELeave ) CAknWaitDialog(

                          ( REINTERPRET_CAST( CEikDialog**, &iWaitDlg )),

                            ETrue );

    iWaitDlg->SetTextL( *text );

    CleanupStack::PopAndDestroy( text );

    iWaitDlg->SetCallback( this );

    iWaitDlg->SetTone( CAknNoteDialog::EConfirmationTone );

    iWaitDlg->ExecuteLD( R_WIFIPROT_WAIT_NOTE  );

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" );

    }

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

// CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL()

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

//

void CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" );

    iStatus = KRequestPending; //should be set by service provider

    ShowWaitingDialogL();

    SetActive( );

    SetNextStateAndComplete( EWiFiProtConfiguring );

    CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" );

    }

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

// CWiFiProtActiveRunner::ShowFinalNoteL()

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

//

void CWiFiProtActiveRunner::ShowFinalNoteL()

    {

    CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowFinalNoteL" );

    const TInt KSettingsConfNone = 0;

    const TInt KSettingsConfOne = 1;

    const TInt KSettingsConfMulti = 2;

    const TInt KResourceIdInvalid = 0;

    HBufC* text = NULL;

    TInt resId = KResourceIdInvalid;

    CAknNoteDialog::TTone tone = CAknNoteDialog::ENoTone;

    TInt numberOfNetworksConfigured = 0;

    if ( iIsConnectionNeeded )

        {

        // we have one network configured if we are here

        numberOfNetworksConfigured = 1;

        }

    else

        {

        numberOfNetworksConfigured = iCmArray.Count();

        }

    //more than one = multiple

    if ( numberOfNetworksConfigured > KSettingsConfOne) 

        {

        numberOfNetworksConfigured = KSettingsConfMulti;

        }

    switch ( numberOfNetworksConfigured )

        {

        case KSettingsConfOne :

            {

            CLOG_WRITE( "Show one network configured note " );

            HBufC* name;

            if ( iIsConnectionNeeded )

                {

                // We have to convert the 8-bit SSID to 16-bit 

                HBufC* ssid16 = HBufC::NewLC( (*iIapParametersArray)

                    [iAvailableNetworks[

                            iSelectedNetworkIndex]].iSsid.Length()+1 );

                TPtr ssid16Ptr( ssid16->Des() );

                CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr,

                    (*iIapParametersArray)[iAvailableNetworks[

                                        iSelectedNetworkIndex]].iSsid );

                ssid16Ptr.ZeroTerminate();

                name = ssid16Ptr.AllocL();