/*

* Copyright (c) 2002-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 HotSpot Server Session

*

*/

// INCLUDE FILES

#include "hotspotserver.h"

#include "hotspotsession.h"

#include "hssnotif.h"

#include "hsslogintimer.h"

#include "hsslogouttimer.h"

#include <internetconnectivitycrkeys.h>

#include <WlanCdbCols.h>

#include <starterclient.h>

#include "e32std.h"

#include "am_debug.h"

#include <ecom.h>

#include "hssclientinterface.h"

#include <f32file.h>

#include <apgcli.h>

// Forward declarations

class CWlanMgmtClient;

class MWlanMgmtNotifications;

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

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

// CHotSpotPluginSession

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

//

CHotSpotSession::CHotSpotSession( CHotSpotServer& aServer ) :

    iServer( aServer ), iClient( NULL ), iSrvNotifications ( NULL ), 

    iNotificationHandle( NULL ), iAllowNotifications( ETrue ), iHotspotExtension( ETrue )

	{

	}

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

// ConstructL

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

//

void CHotSpotSession::ConstructL()

    {

    DEBUG( "CHotSpotSession::ConstructL()" );

    iIapSettingsHandler = CHssIapSettingsHandler::NewL();

    iLoginTimer = CHssLoginTimer::NewL( *this );

    iLogoutTimer = CHssLogoutTimer::NewL( *this );

    iMgtClient = CWlanMgmtClient::NewL();

    iRepository = CRepository::NewL( KCRUidInternetConnectivitySettings );

    }

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

// NewL

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

//

CHotSpotSession* CHotSpotSession::NewL( CHotSpotServer& aServer )

    {

    CHotSpotSession* self = new( ELeave ) CHotSpotSession( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); // Should this class have a 2-way constructor?

    return self;

    }

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

// ~CHotSpotSession

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

//

CHotSpotSession::~CHotSpotSession()

	{

	DEBUG( "CHotSpotSession::~CHotSpotSession()" );

	iPendingNotifications.Close();

 	if ( iMgtClient != NULL )

        {

        iMgtClient->CancelNotifications();

        delete iMgtClient;

        }

 	iMgtClient = NULL;

 	if ( iIapSettingsHandler != NULL )

        {

        delete iIapSettingsHandler;

        }

 	iIapSettingsHandler = NULL;

    if ( iClient != NULL )

        {

        delete iClient;

        }

    iClient = NULL;

    if ( iNotifications != NULL )

        {

        delete iNotifications;

        }

    iNotifications = NULL;

    if ( iLoginTimer != NULL )

        {

        iLoginTimer->Cancel();

        delete iLoginTimer;

        }

    iLoginTimer = NULL;

    if ( iLogoutTimer != NULL )

        {

        iLogoutTimer->Cancel();

        delete iLogoutTimer;

        }

    iLogoutTimer = NULL;

    if ( iRepository != NULL )

        {

        delete iRepository;

        }

    iRepository = NULL;

    if ( iIcts != NULL )

        {

        delete iIcts;

        }

    iIcts = NULL;

    DEBUG( "CHotSpotSession::~CHotSpotSession() Done" );

	}

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

// ServiceL

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

//

void CHotSpotSession::ServiceL( const RMessage2& aMessage )

	{

	DEBUG1( "CHotSpotSession::ServiceL message: %d", aMessage.Function() );

	TRAPD( err, DispatchMessageL( aMessage) );

	if (err != KErrNone)

        {

        // Something went wrong. Complete message to let

        // the client to continue

        aMessage.Complete(err);

        } 

	}

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

// ServiceL

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

//

void CHotSpotSession::DispatchMessageL( const RMessage2& aMessage )

    {

    DEBUG( "CHotSpotSession::DispatchMessageL()" );

    TUint value1(NULL);

    TInt value2(NULL);

    TInt err(KErrNone);

    TInt indx(KErrNone);

    TPckgBuf<TInt> iapPackage( iIapId );

    switch ( aMessage.Function() )

        {

        case EHssActivateNotifications :

            iAllowNotifications = EFalse;

   			DEBUG( "CHotSpotSession::ActivateNotificationsL" );

   			if ( iNotifications == NULL )

   				{

   				DEBUG( "CHotSpotSession::DispatchMessageL activated !!!" );

   				iNotifications = new (ELeave) HssNotifications(*this);

				iMgtClient->ActivateNotificationsL( *iNotifications );

 				}

            HandleOrderNotifications( aMessage );

            break;

        case EHssCancelNotifications :

		    iAllowNotifications = EFalse;

   			DEBUG( "CHotSpotSession::CancelNotifications" );

   			iMgtClient->CancelNotifications( );

   			if ( iNotifications != NULL )

   		    	{

   		    	delete iNotifications;

   		    	}

   		    iNotifications = NULL;

   			HandleCancelNotifications( aMessage );

            break;

        case EHssGetScanResults :

            // Handled now in client side. Left here for future use.

            break;

        case EHssRegister :

        	ProcessRegisterL( aMessage );

            break;

        case EHssUnRegister :

        	ProcessUnRegisterL( aMessage );

            break;

        case EHssJoin :

		    iAllowNotifications = EFalse;

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            iIapId = value1;

            indx = iServer.FindMessage(value1, EHssStart );

            if ( indx >= 0 )

                {

            	iServer.CompleteMessage( indx , KErrNone );

                }

            else

                {

                indx = iServer.FindMessage(value1, EHssStartAgain );

                if ( indx >= 0 )

                    {

                    iServer.CompleteMessage( indx , KErrNone );

                    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssCancelStart :

            iServer.SetLogoutFlag( ETrue );

            // Do not send association status to client

            iServer.SetAssociationFlag( EFalse ); 

             // IAP id

            iIapId = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage(iIapId, EHssStart );

            if ( indx >= 0 )

            {

            	iServer.CompleteMessage( indx , KErrAbort);

            }

	        else

            {

             	indx = iServer.FindMessage(iIapId, EHssStartAgain );

                if ( indx >= 0 )

                {

                	iServer.CompleteMessage( indx , KErrAbort );

                }

            }

            aMessage.Complete( KErrNone );

            break;

        case EHssStop :

            iAllowNotifications = EFalse;

           	iServer.SetLogoutFlag( ETrue );

           	iLoginTimer->Cancel();

            iLogoutTimer->Cancel();

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            for (TInt counter = EHssGetScanResults; counter <EHssServerShutdown ;counter++)

            {

            	indx = iServer.FindMessage(value1, THotSpotCommands(counter ));

            	if ( indx >= 0 )

            	{

            		iServer.CompleteMessage( indx , KErrCancel);

            	}

            }

            aMessage.Complete( KErrNone );

            break;

        case EHssLoginComplete :

		    iAllowNotifications = EFalse;

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            // ret value

            value2 = ( TInt )aMessage.Int1();

            iLoginTimer->Cancel();

            DEBUG1( "EHssLoginComplete value2: %d", value2 );

            indx = iServer.FindMessage( value1, EHssStartLogin );

            if ( KErrNotFound != indx )

                {

            	if (value2 == KErrNone)

            	    {

            	    DEBUG( "EHssLoginComplete1" );

                	iServer.CompleteMessage( indx, KErrNone );

            	    }

            	else

            	    {

            	    DEBUG( "EHssLoginComplete2" );

            		iServer.CompleteMessage( indx, KErrCancel );

                    iServer.SetLogoutFlag( ETrue );

            	    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssLogoutComplete :

		    iAllowNotifications = EFalse;

		    iLogoutTimer->Cancel();

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage( value1, EHssCloseConnection );

            if ( KErrNotFound != indx )

                {

                iServer.CompleteMessage( indx, KErrNone );    

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStartLogin :

            // Do not send association status, since it's already done.

            iServer.SetAssociationFlag( EFalse ); 

            // IAP id

            iIapId = ( TInt )aMessage.Int0();

            // Network id

            iNetId = ( TInt )aMessage.Int1();

            err = iServer.SaveMessage( iIapId, aMessage, EHssStartLogin ); 

            if ( KErrNone != err )

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessStartLoginL( iIapId, iNetId );

                // If client not found, an error was returned. 

                // Otherwise message completed elsewhere. 

                if ( KErrNone != err )

                    {

                    indx = iServer.FindMessage(iIapId, EHssStartLogin );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNone );

                        }

                    else

                        {

                        aMessage.Complete( KErrNone );

                        }

                    }

                }

            break;

        case EHssCancelLogin :

        	iLoginTimer->Cancel();

            // if client doesn't exist (is NULL), Login(.) has not been 

            // called to client -> that is CancelLogin() not needed to call

            if ( iClient != NULL )

                {

                iClient->CancelLogin( iIapId );

                }

            indx = iServer.FindMessage(iIapId, EHssStartLogin );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , err );

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStart:

        	// IAP id

        	iServer.SetLoginFlag( ETrue );

        	iIapId = ( TInt )aMessage.Int0();

            err = iServer.SaveMessage( iIapId, aMessage, EHssStart ); 

           if ( err != KErrNone)

                {

                aMessage.Complete( err );  

                }

            else

                {

                TRAPD( startLeaved, err = ProcessStartL( iIapId ) );

                if ( startLeaved != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStart );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNotSupported );

                        }

                    else

                        {

                        aMessage.Complete( KErrNotSupported );

                        }

                    }

                else if ( err != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStart );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNotSupported );

                        }

                    else

                        {

                        aMessage.Complete( KErrNotSupported );

                        }

                    }

                // else -> client is created and called 

                // WLAN agent waits for 30 seconds before continuing connection setup.

                }

            break;

        case EHssStartAgain:

        	// IAP id

        	iServer.SetLoginFlag( ETrue );

        	iIapId = ( TInt )aMessage.Int0();

            err = iServer.SaveMessage( iIapId, aMessage, EHssStartAgain ); 

           if ( err != KErrNone)

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessStartAgain( iIapId );

                if (   err != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStartAgain );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , err );

                        }

                    else

                        {

                        aMessage.Complete( err );

                        }

                    }

                }

        	break;

        case EHssCancel:

       		iLoginTimer->Cancel();

            iLogoutTimer->Cancel();

         	// IAP id

        	iIapId = ( TInt )aMessage.Int0();

            if ( iServer.GetAssociationFlagValue() )

                {

                // We are in association phase and Agent failed it for some reason

                ProcessAssociationStatus( iIapId, EFalse );

                }

            indx = iServer.FindMessage(iIapId, EHssStart );

            if ( indx >= 0 )

            	{

            	iServer.CompleteMessage( indx , KErrCancel );

            	}

            indx = iServer.FindMessage(iIapId, EHssStartAgain );

            if ( indx >= 0 )

            	{

            	iServer.CompleteMessage( indx , KErrCancel );

            	}

            indx = iServer.FindMessage(iIapId, EHssCloseConnection );

            if ( indx >= 0 )

            	{

            	iServer.CompleteMessage( indx , KErrCancel );

            	}

            //Not needed to send Logout()

            //iServer.SetLogoutFlag( ETrue )

            //ProcessCloseL( iIapId )

			aMessage.Complete( KErrNone );

        break;

        case EHssCloseConnection:

            iLoginTimer->Cancel();

            iLogoutTimer->Cancel();       	

        	// IAP id

        	iIapId = ( TInt )aMessage.Int0();

            if ( iServer.GetAssociationFlagValue() )

                {

                // We are in association phase and Agent failed it for some reason

                ProcessAssociationStatus( iIapId, EFalse );

                }

            err = iServer.SaveMessage( iIapId, aMessage, EHssCloseConnection ); 

            if ( KErrNone != err )

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessCloseL( iIapId );

                // If client not found, an error was returned. 

                // Otherwise message completed elsewhere. 

                if ( KErrNone != err )

                    {

                    indx = iServer.FindMessage(iIapId, EHssCloseConnection );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNone );

                        }

                    else

                        {

                        aMessage.Complete( KErrNone );

                        }

                    }

                }

            break;

        case EHssServerShutdown:

            ProcessServerShutdown( aMessage );

            break;

        case EHssGetIAP:

	        aMessage.WriteL( 0, iapPackage );

            aMessage.Complete( KErrNone );

            break;

        case EHssUiState:

            ProcessUiState( aMessage );

            break;

        case EHssStartBrowser:

            {   

        	TInt len = aMessage.GetDesLength( 0 );

        	iIapId = ( TInt )aMessage.Int1();

        	iNetId = ( TInt )aMessage.Int2();

        	err = iServer.SaveMessage( iIapId, aMessage, EHssStartBrowser );

        	HBufC* buf = HBufC::NewLC( len ); 

            TPtr ptr( buf->Des() );

            User::LeaveIfError( aMessage.Read( 0, ptr ) );     

            AuthenticateL( ptr );

            CleanupStack::PopAndDestroy(buf);

            }

        	break;

        case EHssSetTimerValues:

            {

            TUid clientUid( TUid::Uid( aMessage.Int0() ) );

            TUint loginTimerValue = aMessage.Int1();

            TUint logoutTimerValue = aMessage.Int2();