/*

* Copyright (c) 2004-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: MPM server session implementation

*

*/

/**

@file mpmserversession.cpp

Mobility Policy Manager server session implementation.

*/

// INCLUDE FILES

#include <e32svr.h>

#include <gsmerror.h>     // KErrPacketDataTsyMaxPdpContextsReached 

#include <etelpckt.h>     // KErrUmtsMaxNumOfContextExceededByNetwork

#include <bldvariant.hrh>                // For feature flags

#include <centralrepository.h>           // CRepository 

#include <CoreApplicationUIsSDKCRKeys.h> // KCRUidCoreApplicationUIs, 

                                         // KCoreAppUIsNetworkConnectionAllowed

#include <es_sock.h>

#include <commdb.h>

#include <commdbconnpref.h>

#include <cmpluginbaseeng.h>

#include <cdblen.h>

#include <cmgenconnsettings.h>

#include "mpmcommsdataccess.h"

#include "mpmserversession.h"

#include "mpmconnmonevents.h"

#include "mpmdialog.h"

#include "mpmdisconnectdlg.h"

#include "mpmconfirmdlgstarting.h"

#include "mpmconfirmdlgroaming.h"

#include "mpmlogger.h"

#include "mpmpropertydef.h"

#include "mpmdefaultconnection.h"

#include "mpmiapselection.h"

#include "mpmcsidwatcher.h"

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

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

// CMPMServerSession::NewL

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

//

CMPMServerSession* CMPMServerSession::NewL(CMPMServer& aServer)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMPMServerSession::CMPMServerSession

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

//

CMPMServerSession::CMPMServerSession(CMPMServer& aServer)

    : CSession2(), 

      iMyServer( aServer ),

      iDisconnectDlg( NULL ),

      iConfirmDlgRoaming( NULL ),

      iStoredIapInfo(),

      iIapSelection( NULL ),

    {

    }

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

// CMPMServerSession::ConstructL

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

//

void CMPMServerSession::ConstructL()

    {

    MPMLOGSTRING( "CMPMServerSession::ConstructL" )

    if ( !iMyServer.Events() )

        {

        iMyServer.SetEvents(CMPMConnMonEvents::NewL(

            *const_cast<CMPMServer*>( &iMyServer ), *this ));

        }

    // Append session pointer to server

    // 

    iMyServer.AppendSessionL( this );

    }

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

// CMPMServerSession::~CMPMServerSession

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

//

CMPMServerSession::~CMPMServerSession()

    {

    delete iDisconnectDlg;

    delete iConfirmDlgRoaming;

    delete iIapSelection;

    // Remove serverside objects for notification session.

    // 

    iMyServer.RemoveSession( this );

    if (UserConnection())

        {

        iMyServer.ClearUserConnection();

        ClearUserConnection();

        // Set PS keys to zero

        RProperty::Set( KMPMUserConnectionCategory,

                        KMPMPSKeyUserConnectionSnap,

                        0 );

        RProperty::Set( KMPMUserConnectionCategory,

                        KMPMPSKeyUserConnectionIap,

                        0 );

        MPMLOGSTRING( "CMPMServerSession::HandleServerApplicationConnectionEnds -\

User connection deactivated" )

        }   

    // Clean up the blacklist table 

    iMyServer.HandleServerUnblackListIap( iConnId, 0 );

    // Make sure the connection is removed from server's information array.

    iMyServer.RemoveBMConnection( iConnId, *this );

    }

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

// CMPMServerSession::ServiceL

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

//

void CMPMServerSession::ServiceL( const RMessage2& aMessage )

    {

    switch ( aMessage.Function() )

        {

        case EMPMServerChooseIap:

            {

            HandleServerChooseIapL( aMessage );

            break;

            }

        case EMPMServerCancelRequest:

            {

            HandleServerCancelRequest( aMessage );

            break;

            }

        case EMPMServerApplicationLeavesConnection:

            {

            HandleServerApplicationLeavesConnection( aMessage );

            break;

            }

        case EMPMServerIapConnectionStopped:

            {

            HandleServerIapConnectionStopped( aMessage );

            break;

            }

        case EMPMServerProcessError:

            {

            HandleServerProcessErrorL( aMessage );

            break;

            }

        case EMPMServerRegisterPrefIAPNotif:

            {

            HandleServerRegisterPrefIAPNotifL( aMessage ); 

            break;

            }

        case EMPMServerUnregisterPrefIAPNotif:

            {

            HandleServerUnregisterPrefIAPNotif( aMessage );

            break;

            }

        case EMPMServerWaitNotification:

            {

            HandleServerWaitNotificationL( aMessage );

            break;                                              

            }

        case EMPMServerSortSNAP:

            {

            HandleServerSortSNAPL( aMessage ); 

            break;

            }

        case EMPMServerApplicationJoinsConnection:

            {

            HandleServerApplicationJoinsConnection( aMessage );

            break;

            }

        case EMPMServerIapConnectionActivated:

            {

            HandleServerIapConnectionActivatedL( aMessage );

            break;

            }

        case EMPMServerIapConnectionStarted:

            {

            HandleServerIapConnectionStartedL( aMessage );

            break;

            }

        case EMPMServerApplicationConnectionEnds:

            {

            HandleServerApplicationConnectionEnds( aMessage );

            break;

            }

        case EMPMServerApplicationMigratesToCarrier:

            {

            HandleServerApplicationMigratesToCarrierL( aMessage );

            break;

            }

        case EMPMServerApplicationIgnoredTheCarrier:

            {

            HandleServerApplicationIgnoredTheCarrier( aMessage );

            break;

            }

        case EMPMServerApplicationAcceptedTheCarrier:

            {

            HandleServerApplicationAcceptedTheCarrier( aMessage );

            break;

            }

        case EMPMServerApplicationRejectedTheCarrier:

            {

            HandleServerApplicationRejectedTheCarrierL( aMessage );

            break;

            }

        case EMPMServerEasyWlanSsid:

            {

            // Easy WLAN SSID not used anymore as connecting 

            // notes have been removed

            //

            MPMLOGSTRING( "CMPMServerSession::ServiceL \

completing EMPMServerEasyWlanSsid" )

            aMessage.Complete( KErrNone );

            break;

            }

        case EMPMServerReselectIap:

            {

            HandleServerReselectIapL( aMessage );

            break;

            }

#ifdef _DEBUG

        case EMPMDebugGenerateStopIAPNotification:

            {

            HandleDebugGenerateStopIAPNotification( aMessage );

            break;

            }

        case EMPMDebugSwitchConnMonEventsOn:

            {

            HandleDebugFilterConnMonEvents( aMessage, EFalse );

            break;

            }

        case EMPMDebugSwitchConnMonEventsOff:

            {

            HandleDebugFilterConnMonEvents( aMessage, ETrue );

            break;

            }

        case EMPMDebugShutdown:

            {

            HandleDebugShutdown( aMessage, ETrue );

            break;

            }    

#endif //_DEBUG

        default:

            {

            iMyServer.PanicClient( KErrNotSupported );

            }

        }

    }

#ifdef _DEBUG

void CMPMServerSession::HandleDebugGenerateStopIAPNotification( const RMessage2& aMessage )

    {

    MPMLOGSTRING( "CMPMServerSession::HandleDebugGenerateStopIAPNotification" )

    TInt iap = static_cast<TInt>( aMessage.Int0() );

    MyServer().StopConnections( iap );

    aMessage.Complete( KErrNone );

    }

void CMPMServerSession::HandleDebugFilterConnMonEvents( const RMessage2& aMessage, const TBool aVal )

    {

    MPMLOGSTRING2( "CMPMServerSession::HandleDebugFilterConnMonEvents FilteringEnabled=%d", aVal )

    TInt iap = static_cast<TInt>( aMessage.Int0() );

    MyServer().Events()->FilterAvailableIAPEvents( aVal );

    aMessage.Complete( KErrNone );

    }

void CMPMServerSession::HandleDebugShutdown( const RMessage2& aMessage, const TBool /*aVal*/ )

    {

    MPMLOGSTRING( "CMPMServerSession::HandleDebugShutdown" )

    aMessage.Complete( KErrNone );

    TFindProcess processFinder( _L("*MPMServer*") );

    TFullName    name;

    if ( processFinder.Next( name ) == KErrNone ) 

        {

        RProcess process;

        TInt err = process.Open( name );

        if ( err == KErrNone ) 

            {

            process.Kill( 0 );

            }

        process.Close();

        }    

    }    

#endif //_DEBUG

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

// CMPMServerSession::ServiceError

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

//

void CMPMServerSession::ServiceError( const RMessage2& aMessage, 

                                      TInt             aError )

    {

    // Handles the situation when a call to CSession2::ServiceL(), 

    // which services a client request, leaves.

    // 

    // The default behaviour of this function is to complete the message, 

    // using the leave value, if it has not already been completed.

    // 

    // Servers can re-implement this as appropriate.

    // 

    MPMLOGSTRING3(

        "CMPMServerSession::ServiceError: Service %d failed with error: %d",

         aMessage.Function(),

         aError )

    if( aMessage.Function() == EMPMServerChooseIap ||

        aMessage.Function() == EMPMServerReselectIap )

        {

        // complete locally stored iChooseIapMessage

        //

        ChooseIapComplete( aError, NULL );

        }

    else if( aMessage.Function() == EMPMServerProcessError )

        {

        // complete locally stored iProcessErrorMessage

        //

        ProcessErrorComplete( aError, NULL, NULL );

        }

    else if( !aMessage.IsNull() )

        {

        // Complete message if it hasn't been 

        // already completed

        //

        aMessage.Complete( aError );        

        }

    else

        {

        MPMLOGSTRING(

        "CMPMServerSession::ServiceError: Message has already been completed" )

        }    

    }

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

// CMPMServerSession::HandleServerChooseIapL

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

//

void CMPMServerSession::HandleServerChooseIapL( const RMessage2& aMessage )

    {

    MPMLOGSTRING2( "CMPMServerSession::HandleServerChooseIapL session <0x%x>", this )

    // Read the Connection Id of the application

    //

    iConnId = aMessage.Int1();

    MPMLOGSTRING2( "CMPMServerSession::HandleServerChooseIapL: \

Connection Id = 0x%x", iConnId )

    // Sanity check that client only has one outstanding ChooseBestIAP() or ReselectBestIAP() -call.

    //

    if ( !iChooseIapMessage.IsNull() )

        {

        MPMLOGSTRING2( "CMPMServerSession::HandleServerChooseIapL: - Error \

ChooseBestIAP() or ReselectBestIAP() already exists %d", KErrServerBusy );

        aMessage.Complete( KErrServerBusy );

        }

    // Sanity check that client doesn't call ChooseBestIAPL() twice for the same session.

    //

    if ( ChooseBestIapCalled() )

        {

        MPMLOGSTRING2( "CMPMServerSession::HandleServerChooseIapL: - Error \

ChooseBestIAP() already completed or in progress %d", KErrAlreadyExists )

        aMessage.Complete( KErrAlreadyExists );

        return;

        }

    // We must save the RMessage in order to complete it later.

    //

    iChooseIapMessage = aMessage;

    TConnPref connPref;

    aMessage.ReadL( KFirstArgument, connPref );

    // Extract connection preferences

    //

    TMpmConnPref mpmConnPref;

    TInt error = ExtractConnPref( connPref, mpmConnPref );

    if ( error != KErrNone )

        {

        // Connection preferences are not valid. Display

        // an error note and complete with the error code.

        //

        if ( ! ( mpmConnPref.NoteBehaviour() &

            TExtendedConnPref::ENoteBehaviourConnDisableNotes ) )

            {

            CConnectionUiUtilities* connUiUtils = NULL;

            TRAP_IGNORE( connUiUtils = CConnectionUiUtilities::NewL() );

            if ( connUiUtils )

                {

                connUiUtils->ConnectionErrorDiscreetPopup( error );

                delete connUiUtils;

                connUiUtils = NULL;

                }

            }    	

        MPMLOGSTRING( "CMPMServerSession::HandleServerChooseIapL - Error \

while extracting TCommDbConnPref from TConnPref" )

        aMessage.Complete( error );

        return;

        }

    // Store the Uid of the application to the member variable so 

    // that it can be used to avoid DisconnectDialog popping up when 

    // AlwaysOnline connection is being established.

    // 

    iAppUid = aMessage.Int2();

    MPMLOGSTRING2( "CMPMServerSession::HandleServerChooseIapL: \

Client UID = 0x%x", iAppUid )

    if ( !iIapSelection )

        {

        iIapSelection = CMPMIapSelection::NewL( iMyServer.CommsDatAccess(),

                                                this ); 

        }

    MPMLOGSTRING3( "CMPMServerSession::HandleServerChooseIapL - iap %d \

connType %d", mpmConnPref.IapId(), mpmConnPref.ConnType() )

    iIapSelection->ChooseIapL( mpmConnPref );

    if ( iAppUid == iMyServer.CsIdWatcher()->ConnectScreenId() )

        {

        MPMLOGSTRING( "CMPMServerSession::HandleServerChooseIapL -\

 User connection activated" )

        // This is user connection

        iMyServer.SetUserConnection();

        SetUserConnection();

        iMyServer.SetUserConnPref( mpmConnPref );

        // Set PS keys according to user connection

        // Do not check return values. Can do nothing in case of failing.

        RProperty::Set( KMPMUserConnectionCategory,

                        KMPMPSKeyUserConnectionSnap,

                        mpmConnPref.SnapId() );

        RProperty::Set( KMPMUserConnectionCategory,

                        KMPMPSKeyUserConnectionIap,

                        mpmConnPref.IapId() );

        }

    }

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

// CMPMServerSession::HandleServerCancelRequest

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

//

void CMPMServerSession::HandleServerCancelRequest( const RMessage2& aMessage )

    {

    TInt cancelcode = aMessage.Int0();

    MPMLOGSTRING2(

        "CMPMServerSession::HandleServerCancelRequest - Request code = %i", 

        cancelcode )

    switch ( cancelcode )

        {

        case EMPMReselectBestIAP:

        case EMPMChooseBestIAP:

            {

            // Complete original request

            // 

            ChooseIapComplete( KErrCancel, NULL );

            // Complete cancel request 

            //

            MPMLOGSTRING(

            "CMPMServerSession::HandleServerCancelRequest - Complete with KErrNone" )

            aMessage.Complete( KErrNone );

            // Cancel WLAN scan request if one exists

            //

            TRAP_IGNORE( iMyServer.Events()->CancelScanL( *this ) )

            if ( iIapSelection )

                {

                delete iIapSelection;

                iIapSelection = NULL;

                }

            return;

            }

        case EMPMProcessError:

            {

            ProcessErrorComplete( KErrCancel,

                                  NULL,

                                  NULL );

            // Complete cancel request 

            //

            MPMLOGSTRING(