/*

* Copyright (c) 2002-2009 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:  WLAN Agent state machine's state implementations

*

*/

/*

* %version: 35 %

*/

#include <connectprog.h>

#include <comms-infras/dbaccess.h>

#include <commdb.h>

#include <wdbifwlansettings.h>

#include <badesca.h>

#include <e32ver.h>

#include <utf.h>

#include "am_debug.h"

#include "genscanlist.h"

#include "genscaninfo.h"

#include "wlanagtstates.h"

#include "wlanagtsm.h"

#include "wlanagthotspotclient.inl"

static const TUint KConnectionEndWaitTime = 2*1000000; // 2 seconds

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

// CWlanStateBase::CWlanStateBase

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

//

CWlanStateBase::CWlanStateBase( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) :

	CAgentStateBase( *aWlanSM ),

	iWlanSM( aWlanSM ),

	iWLMServer( aWLMServer )

    {

    }

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

// CWlanStateBase::StartState

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

//

void CWlanStateBase::StartState()

    {

	JumpToRunl( KErrNone );

    }

// Default implementations for the functions from MWLMNotify don't do anything.

// If a state is interested in the notifications, it should 'activate' notifications

// and override these.

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

// CWlanStateBase::ConnectionStateChanged

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

//

void CWlanStateBase::ConnectionStateChanged( TWlanConnectionState /* aNewState */ )

    {

	DEBUG( "CWlanStateBase::ConnectionStateChanged()" );

    }

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

// CWlanStartState::CWlanStartState

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

//

CWlanStartState::CWlanStartState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) :

	CWlanStateBase( aWlanSM, aWLMServer ),

	iNextState( EWlanAgtNextStateUnknown )

    {

	DEBUG( "CWlanStartState constructor" );

    }

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

// CWlanStartState::RunL

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

//

void CWlanStartState::RunL()

    {

	if( iWlanSM->WlanSettings()->SSID.Length() == 0 )

        {

        PrepareEasyWlanParamsL();

        }

	DEBUG( "CWlanStartState: next state: EWlanAgtNextStateJoin" );

	iNextState = EWlanAgtNextStateJoin;

	iWlanSM->CompleteState( KErrNone );

    }

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

// CWlanStartState::PrepareEasyWlanParamsL

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

//

void CWlanStartState::PrepareEasyWlanParamsL()

    {

	DEBUG( "CWlanStartState::PrepareEasyWlanParamsL()" );

    TPckgBuf<TWep> iWep;

    TPtr8 wepPtr( &iWep().KeyMaterial[0], KWLMMaxWEPKeyLength );

	TPckgBuf<TWpaPsk> iPsk;

	TPtr8 pskPtr( &iPsk().KeyMaterial[0], KWLMMaxWpaPskLength );

	TWLMOverrideSettings overrides;

	Mem::FillZ(&overrides, sizeof(overrides));

	TBuf8<KMaxSSIDLength> ssid8;

	CnvUtfConverter::ConvertFromUnicodeToUtf8( ssid8, iWlanSM->WlanSettings()->UsedSSID );

	overrides.settingsMask = EOverrideSsidMask;

	overrides.ssid.ssidLength = ssid8.Length(); 

	Mem::Copy(overrides.ssid.ssid, ssid8.Ptr(), overrides.ssid.ssidLength);

    if ( (iWlanSM->WlanSettings())->ConnectionMode == Adhoc )

        {

    	DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), conn mode: Adhoc" );

        overrides.settingsMask |= EOverrideIbssMask;

        }

    // Set security mode and parameters

	switch( iWlanSM->WlanSettings()->SecurityMode )

    	{

        case AllowUnsecure:

        	DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Open" );

            break;

        case Wep:

        	DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wep" );

            overrides.settingsMask |= EOverrideWepMask;                

            Mem::Copy(&iWep().KeyMaterial[0], &((iWlanSM->WlanSettings()->WepKey1).KeyMaterial[0]), (iWlanSM->WlanSettings()->WepKey1).KeyLength);

            iWep().KeyIndex = (iWlanSM->WlanSettings()->WepKey1).KeyIndex;

            iWep().KeyLength = (iWlanSM->WlanSettings()->WepKey1).KeyLength;

            overrides.wep = iWep();

            break;

        case Wlan8021x:

        case Wpa:

        case Wpa2Only:

        	if ( iWlanSM->WlanSettings()->EnableWpaPsk )

        		{

        		DEBUG1( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wpa-psk,len:%d", 

        				iWlanSM->WlanSettings()->WPAKeyLength );

        		overrides.settingsMask |= EOverrideWpaPskMask;

        		pskPtr.Copy( iWlanSM->WlanSettings()->WPAPreSharedKey );

        	    iPsk().KeyLength = iWlanSM->WlanSettings()->WPAKeyLength;

        	    overrides.wpaPsk = iPsk();        		

        		}

        	else

        		{

        		DEBUG( "CWlanStartState::PrepareEasyWlanParamsL(), security mode: Wpa" );

        		overrides.settingsMask |= EOverrideWpaMask;

        		}

            break;

        default:

        	DEBUG1( "CWlanStartState::PrepareEasyWlanParamsL(), wrong security mode value in commsdat:%d",

        							iWlanSM->WlanSettings()->SecurityMode );

        	User::LeaveIfError(KErrGeneral);

		    return;

    	}

	iWlanSM->SetOverrideSettingsL( overrides );

    }

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

// CWlanStartState::NextStateL

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

//

CAgentStateBase* CWlanStartState::NextStateL(TBool aContinue)

    {

	DEBUG( "CWlanStartState::NextStateL()" );

	if( aContinue )

	    {

		switch(iNextState)

		    {

    		case EWlanAgtNextStateJoin:

    			return new (ELeave) CWlanJoinState(iWlanSM, iWLMServer);

    		case EWlanAgtNextStateOpen:

    			return new (ELeave) CWlanOpenState(iWlanSM, iWLMServer);

    		default:

	    		return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect );

		    }

	    }

	else

	{

	    return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect );

	}

    }

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

// CWlanStartState::DoCancel

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

//

void CWlanStartState::DoCancel()

    {

    }

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

// CWlanJoinState::CWlanJoinState

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

//

CWlanJoinState::CWlanJoinState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) :

	CWlanStateBase( aWlanSM, aWLMServer )

    {

    DEBUG( "CWlanJoinState constructor" );

    }

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

// CWlanJoinState::~CWlanJoinState

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

//

CWlanJoinState::~CWlanJoinState()

    {

	DEBUG( "CWlanJoinState destructor" );

	Cancel();

	if ( iAgtHotSpotClient )

	    {

	    delete iAgtHotSpotClient;

	    }

    }

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

// CWlanJoinState::StartState

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

//

void CWlanJoinState::StartState()

    {

    DEBUG( "CWlanJoinState::StartState()" );

    TRAPD( ret, DoStartStateL() );

    if( ret != KErrNone )

        {

        iContext = EHotSpotFailure;

        JumpToRunl( ret );

        }

    }

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

// CWlanJoinState::DoStartStateL

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

//

void CWlanJoinState::DoStartStateL()

    {

    DEBUG( "CWlanJoinState::DoStartStateL()" );

    // check if plug-in is available

    TRAPD( ret, iAgtHotSpotClient = CWlanAgtHotSpotClient::NewL() );

    if ( ret == KErrNone )

        {

        DEBUG( "CWlanJoinState::DoStartStateL(), AgtHotSpot plugin available" );

        //Assume that AP is HotSpot AP. Later if HS Server says its not HS AP, then it will be set as normal AP

        iWlanSM->SetHotSpotAP( ETrue );

        // talk to hotspot server	

        DEBUG( "CWlanJoinState::DoStartStateL(), Sending Start message to HotSpot Server" );

        iAgtHotSpotClient->HotSpotStart( iWlanSM->IapId(), iStatus );

        iContext = EHotSpotInProgress;

        SetActive();

        }

    else

        {

        iAgtHotSpotClient = NULL;

        DEBUG(  "CWlanJoinState::DoStartStateL(), Couldn't find AgtHotSpot plug-in,defaulting to normal procedure" );

        iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() );

        SetActive();

        }

    }

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

// CWlanJoinState::NextStateL

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

//

CAgentStateBase* CWlanJoinState::NextStateL( TBool aContinue )

    {

	DEBUG( "CWlanJoinState::NextStateL()" );

	if( aContinue )

	    {

	    return new (ELeave) CWlanOpenState( iWlanSM, iWLMServer );

	    }

   	else if( iStatus.Int() == KErrWlanConnAlreadyActive )

        {

        return new(ELeave) CWlanErrorState( iWlanSM, KErrWlanConnAlreadyActive );

        }

   	else

        {

        return new(ELeave) CWlanErrorState( iWlanSM, KErrCouldNotConnect );

        }

    }

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

// CWlanJoinState::RunL

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

//

void CWlanJoinState::RunL()

    {

    DEBUG1( "CWlanJoinState::RunL(), iStatus = %i", iStatus.Int() );

    if( iAgtHotSpotClient )

	{

	switch( iContext )

	    {

	    case EHotSpotInProgress:

		if( iStatus != KErrNone )

		    {

		    if( iStatus == KErrNotSupported )

		        {

                DEBUG( "CWlanJoinState::RunL(), HotSpot Server returned KErrNotSupported, treating it as normal AP" );

                iWlanSM->SetHotSpotAP( EFalse );

                iContext = EHotSpotNormalAP;

                }

		    else

		        {

		        DEBUG( "CWlanJoinState::RunL(), Error returned by HotSpot Server" );

		        iContext = EHotSpotFailure;

		        }

		    iAgtHotSpotClient->HotSpotCloseConnection( iWlanSM->IapId(), iStatus );

		    SetActive();

		    }

		else

		    {

		    // send Join request to WLM server

		    DEBUG( "CWlanJoinState::RunL(), Sending Join request to Engine" );

		    iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() );

		    iContext = EHotSpotWLMServerHS;

		    SetActive();

		    }

		break;

	    case EHotSpotWLMServerHS:

		if(iStatus != KErrNone)

		    {

		    DEBUG( "CWlanJoinState::RunL(), Join failed, Continue trying with HOTSPOT Server" );

		    iAgtHotSpotClient->HotSpotStartAgain( iWlanSM->IapId(), iStatus );

		    iContext = EHotSpotInProgress;

		    SetActive();

		    }

		else

		    {

		    DEBUG( "CWlanJoinState::RunL(), Successfully joined to network,  CloseConnection will be called from Disconnect State");

		    DEBUG( "CWlanJoinState::RunL(), Sending ServiceStarted indication to NIFMAN" );

		    iSMObserver->ServiceStarted();

		    iWlanSM->CompleteState( KErrNone );

		    }

		break;

	    case EHotSpotNormalAP:

		// send Join request to WLM server

		DEBUG( "CWlanJoinState::RunL(), Sending Join request to Engine" );

		iWLMServer.Join( iStatus, iWlanSM->SettingsId(), iWlanSM->OverrideSettings() );

		iContext = EHotSpotWLMServerNormal;

		SetActive();

		break;

	    case EHotSpotWLMServerNormal:

		if(iStatus != KErrNone)

		    {   

		    DEBUG1( "CWlanJoinState::RunL(), Join failed(%d), not retrying with HotSpot Server, as this is normal AP", iStatus.Int() );

		    iSMObserver->ConnectionComplete( EAttemptingToJoin, iStatus.Int() );

		    }

		else

		    {

		    DEBUG( "CWlanJoinState::RunL(), Successfully joined to network,Sending ServiceStarted indication to NIFMAN" );

		    iSMObserver->ServiceStarted();

		    iWlanSM->CompleteState( KErrNone );

		    }

		break;

	    case EHotSpotFailure:

		DEBUG( "CWlanJoinState::RunL(), Cancelling the Join operation" );

		iSMObserver->ConnectionComplete( EAttemptingToJoin, KErrCouldNotConnect );

		break;

	    default:

		DEBUG( "CWlanJoinState::RunL(), Unknown Active Object context, Panicing.." );

    		User::Panic( _L("wlanagt"), KErrGeneral );

    		break;

	    }

	}

    else

	{

	//Normal AP

	if(iStatus != KErrNone)

	    {

	    iSMObserver->ConnectionComplete( EAttemptingToJoin, iStatus.Int() );

	    return;

	    }

	else

	    {

	    DEBUG( "CWlanJoinState::RunL(), Successfully joined to network" );

	    // Nifman loads the NIF after a ServiceStarted() call

	    iSMObserver->ServiceStarted();

	    iWlanSM->CompleteState( KErrNone );

	    }

	}

    }

// CWlanJoinState::DoCancel

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

//

void CWlanJoinState::DoCancel()

    {

    DEBUG( "CWlanJoinState::DoCancel()" );

    if ( iAgtHotSpotClient )

        {

        //Cancel is sent to HSS even if there is no pending request, so that CloseConnection is not 

        //required to be called seperately

        DEBUG( "CWlanJoinState::DoCancel(), Sending Cancel to HotSpot Server" );

        iAgtHotSpotClient->HotSpotCancel( iWlanSM->IapId() );

        }

    // If Join request is sent to Engine, cancel it by sending Release request

    if ( !(iAgtHotSpotClient) || iContext == EHotSpotWLMServerHS || 

		iContext == EHotSpotWLMServerNormal )

        {

        DEBUG( "CWlanJoinState::DoCancel(), Sending Release to WLM Server" );

        iWLMServer.Release();

        }

    }

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

// CWlanOpenState::CWlanOpenState

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

//

CWlanOpenState::CWlanOpenState( CWlanSM* aWlanSM, RWLMServer& aWLMServer ) :

	CWlanStateBase( aWlanSM, aWLMServer ),

	iSubState( EWlanOpenSubStateOpening )

    {

	DEBUG( "CWlanOpenState constructor" );

    }

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

// CWlanOpenState::StartState

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

//

void CWlanOpenState::StartState()

    {

	DEBUG( "CWlanOpenState::StartState()" );

	TRAPD( ret, DoStartStateL() );

	JumpToRunl( ret );

    }

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

// CWlanOpenState::DoStartStateL

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

//

void CWlanOpenState::DoStartStateL()

    {

	DEBUG( "CWlanOpenState::DoStartStateL()" );

    // @to do: whether this callback system is needed anymore or not,

    // should be checked.

	// Create a callback for handling the "disconnect" notification from 

	// WLM. We must use async callback to avoid deleting iNotify of RWLMServer 

	// "too early" (ConnectionStateChanged() notification call from WLM must 

	// not result to calling CancelNotifies() of RWLMServer synchronously).

	TCallBack callback( DisconnectCb, this );

	iDisconnectCb = new (ELeave) CAsyncCallBack( callback, CActive::EPriorityStandard );

    }

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

// CWlanOpenState::NextStateL

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

//

CAgentStateBase* CWlanOpenState::NextStateL( TBool /*aContinue*/ )

    {

	DEBUG( "CWlanOpenState::NextStateL(), calling RWLMServer::CancelNotifies()" );

	iWLMServer.CancelNotifies();

	return new (ELeave) CWlanDisconnectState( iWlanSM, iWLMServer );

    }

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

// CWlanOpenState::RunL

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

//

void CWlanOpenState::RunL()

    {

	DEBUG( "CWlanOpenState::RunL()" );

	switch( iSubState )

	    {

	    case EWlanOpenSubStateOpening:

		    if( iStatus != KErrNone )

		        {

			    iSMObserver->ConnectionComplete( EOpeningConnection, iStatus.Int() );

			    return;

		        }

		    DEBUG( "CWlanOpenState::RunL(), Connection Complete with KErrNone" );

    		iSMObserver->ConnectionComplete( KConnectionOpen, KErrNone );

    		iSubState = EWlanOpenSubStateOpened;

    		DEBUG( "CWlanOpenState::RunL(), calling RWLMServer::ActivateNotifiesL()" );

    		iWLMServer.ActivateNotifiesL( *this, EWlmNotifyConnectionStateChanged );

    		break;

    	case EWlanOpenSubStateOpened:

    		User::Panic( _L("wlanagt"), KErrGeneral );

    		break;

    	default:

    		User::Panic( _L("wlanagt"), KErrGeneral );

    		break;

	    }

    }

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

// CWlanOpenState::DoCancel

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

//

void CWlanOpenState::DoCancel()

    {

	DEBUG( "CWlanOpenState::DoCancel()" );

    }