/*

* Copyright (c) 2009-2010 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:

* Handles client requests.

*

*/

#include <sysutil.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginembdestinationdef.h>

#include <cmdefconnvalues.h>

#include "cmmserver.h"

#include "cmmserverdefs.h"

#include "cmmsession.h"

#include "cmmdestinationinstance.h"

#include "cmmconnmethodinstance.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmsessionTraces.h"

#endif

CCmmSession* CCmmSession::NewL( CCmmServer& aServer, CCmmCache& aCache )

    {

    OstTraceFunctionEntry0( CCMMSESSION_NEWL_ENTRY );

    CCmmSession* self = CCmmSession::NewLC( aServer, aCache );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMSESSION_NEWL_EXIT );

    return self;

    }

CCmmSession* CCmmSession::NewLC( CCmmServer& aServer, CCmmCache& aCache )

    {

    OstTraceFunctionEntry0( CCMMSESSION_NEWLC_ENTRY );

    CCmmSession* self = new( ELeave ) CCmmSession( aServer, aCache );

    CleanupStack::PushL( self ) ;

    self->ConstructL() ;

    OstTraceFunctionExit0( CCMMSESSION_NEWLC_EXIT );

    return self ;

    }

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

// Constructor.

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

//

CCmmSession::CCmmSession( CCmmServer& aServer, CCmmCache& aCache )

        :

        iServer( aServer ),

        iCache( aCache ),

        iFsConnected( EFalse )

    {

    OstTraceFunctionEntry0( CCMMSESSION_CCMMSESSION_ENTRY );

    iDestinationContainer = NULL;

    iDestinationObjects = NULL;

    iConnMethodContainer = NULL;

    iConnMethodObjects = NULL;

    OstTraceFunctionExit0( CCMMSESSION_CCMMSESSION_EXIT );

    }

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

// The second phase of two phase construction.

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

//

void CCmmSession::ConstructL()

    {

    OstTraceFunctionEntry0( CCMMSESSION_CONSTRUCTL_ENTRY );

    iServer.IncrementSessions();

    // Create a new object index (it stores the destination objects owned by

    // this session).

    iDestinationObjects = CObjectIx::NewL();

    // Initialize the object container using the object container index in the

    // server (Object container provides unique ids for the objects owned by

    // this session).

    iDestinationContainer = iServer.NewContainerL();

    // The same for connection method subsessions.

    iConnMethodObjects = CObjectIx::NewL();

    iConnMethodContainer = iServer.NewContainerL();

    OstTraceFunctionExit0( CCMMSESSION_CONSTRUCTL_EXIT );

    }

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

// Destructor.

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

//

CCmmSession::~CCmmSession()

    {

    OstTraceFunctionEntry0( DUP1_CCMMSESSION_CCMMSESSION_ENTRY );

    iServer.DecrementSessions();

    delete iDestinationObjects;

    iDestinationObjects = NULL;

    if ( iDestinationContainer != 0 )

        {

        iServer.RemoveContainer( iDestinationContainer );

        iDestinationContainer = NULL;

        }

    delete iConnMethodObjects;

    iConnMethodObjects = NULL;

    if ( iConnMethodContainer != 0 )

        {

        iServer.RemoveContainer( iConnMethodContainer );

        iConnMethodContainer = NULL;

        }

    if ( iFsConnected )

        {

        iFs.Close();

        iFsConnected = EFalse;

        }

    OstTraceFunctionExit0( DUP1_CCMMSESSION_CCMMSESSION_EXIT );

    }

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

// CCmmSession::ServiceL

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

//

void CCmmSession::ServiceL( const RMessage2& aMessage )

    {

    OstTraceFunctionEntry0( CCMMSESSION_SERVICEL_ENTRY );

    TInt result( KErrNone );

    switch ( aMessage.Function() )

        {

        case ECmmGetBearerInfoInt:

            {

            GetBearerInfoIntL( aMessage );

            }

            break;

        case ECmmGetBearerInfoBool:

            {

            GetBearerInfoBoolL( aMessage );

            }

            break;

        case ECmmGetBearerInfoString:

            {

            GetBearerInfoStringL( aMessage );

            }

            break;

        case ECmmGetBearerInfoString8:

            {

            GetBearerInfoString8L( aMessage );

            }

            break;

        case ECmmGetConnMethodInfoInt:

            {

            GetConnMethodInfoIntL( aMessage );

            }

            break;

        case ECmmGetConnMethodInfoBool:

            {

            GetConnMethodInfoBoolL( aMessage );

            }

            break;

        case ECmmGetConnMethodInfoString:

            {

            GetConnMethodInfoStringL( aMessage );

            }

            break;

        case ECmmGetConnMethodInfoString8:

            {

            GetConnMethodInfoString8L( aMessage );

            }

            break;

        case ECmmGetConnMethodArray:

            {

            GetConnMethodArrayL( aMessage );

            }

            break;

        case ECmmGetAllDestinations:

            {

            GetAllDestinationsL( aMessage );

            }

            break;

        case ECmmGetEasyWlanId:

            {

            GetEasyWLANIdL( aMessage );

            }

            break;

        case ECmmRemoveAllReferences: // CM becomes uncategorized.

            {

            RemoveAllReferencesL( aMessage );

            }

            break;

        case ECmmGetSupportedBearers:

            {

            GetSupportedBearersL( aMessage );

            }

            break;

        case ECmmGetUncategorizedIcon:

            {

            GetUncategorizedIconL( aMessage );

            }

            break;

        case ECmmReadDefaultConnection:

            {

            ReadDefaultConnectionL( aMessage );

            }

            break;

        case ECmmWriteDefaultConnection:

            {

            // Default connection is now just internet snap.

            result = KErrNotSupported;

            }

            break;

        case ECmmReadGeneralConnectionSettings:

            {

            ReadGenConnSettingsL( aMessage );

            }

            break;

        case ECmmWriteGeneralConnectionSettings:

            {

            WriteGenConnSettingsL( aMessage );

            }

            break;

        case ECmmGetBearerPriorityArray:

            {

            GetBearerPriorityArrayL( aMessage );

            }

            break;

        case ECmmUpdateBearerPriorityArray:

            {

            UpdateBearerPriorityArrayL( aMessage );

            }

            break;

        case ECmmCopyConnMethod:

            {

            CopyConnMethodL( aMessage );

            }

            break;

        case ECmmMoveConnMethod:

            {

            MoveConnMethodL( aMessage );

            }

            break;

        case ECmmRemoveConnMethod:

            {

            RemoveConnMethodL( aMessage );

            }

            break;

        case EDestGetDestination:

        case EDestRefresh:

        case EDestCreateDestinationWithName:

        case EDestCreateDestinationWithNameAndId:

        case EDestCloseDestination:

        case EDestGetConnMethodCount:

        case EDestGetConnMethodPriority:

        case EDestGetName:

        case EDestGetId:

        case EDestGetElementId:

        case EDestMetadata:

        case EDestGetProtectionLevel:

        case EDestIsConnected:

        case EDestIsHidden:

        case EDestIsEqual:

        case EDestGetIcon:

        case EDestAddConnMethod:

        case EDestAddEmbeddedDestination:

        case EDestDeleteConnMethod:

        case EDestRemoveConnMethod:

        case EDestModifyPriority:

        case EDestSetName:

        case EDestSetMetadata:

        case EDestSetProtection:

        case EDestSetHidden:

        case EDestUpdate:

        case EDestDelete:

        case EDestSetIcon:

            {

            ServiceDestinationL( aMessage );

            }

            break;

        case ECMGetConnMethodWithId:

        case ECMRefresh:

        case ECMCreateConnMethod:

        case ECMCreateConnMethodWithId:

        case ECMGetConnMethodFromDestWithIndex:

        case ECMGetConnMethodFromDestWithId:

        case ECMCreateConnMethodToDest:

        case ECMCreateConnMethodToDestWithId:

        case ECMCreateCopyOfExisting:

        case ECMCloseConnMethod:

        case ECMGetIntAttribute:

        case ECMGetBoolAttribute:

        case ECMGetStringAttribute:

        case ECMGetString8Attribute:

        case ECMIsEqual:

        case ECMSetIntAttribute:

        case ECMSetBoolAttribute:

        case ECMSetStringAttribute:

        case ECMSetString8Attribute:

        case ECMDelete:

        case ECMUpdate:

        case EDestGetEmbeddedDestination:

            {

            ServiceConnMethodL( aMessage );

            }

            break;

        default:

            {

            result = KErrNotSupported;

            }

            break;

        }

    aMessage.Complete( result );

    OstTraceFunctionExit0( CCMMSESSION_SERVICEL_EXIT );

    }

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

// Finds a connection method instance that belongs to this session and matches

// the provided ID. Return NULL if no match is found.

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

//

CCmmConnMethodInstance* CCmmSession::FindConnMethodInstanceById(

        const TUint32 aConnMethodId )

    {

    OstTraceFunctionEntry0( CCMMSESSION_FINDCONNMETHODINSTANCEBYID_ENTRY );

    CCmmConnMethodInstance* wantedConnMethodInstance( NULL );

    for ( TInt i = 0; i < iConnMethodObjects->Count(); i++ )

        {

        CCmmConnMethodInstance* connMethodInstance =

                ( CCmmConnMethodInstance* )( ( *iConnMethodObjects )[i] );

        if ( connMethodInstance && connMethodInstance->GetId() == aConnMethodId )

            {

            wantedConnMethodInstance = connMethodInstance;

            break;

            }

        }

    OstTraceFunctionExit0( CCMMSESSION_FINDCONNMETHODINSTANCEBYID_EXIT );

    return wantedConnMethodInstance;

    }

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

// Finds a destination instance that belongs to this session and matches

// the provided handle.

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

//

CCmmDestinationInstance* CCmmSession::FindDestinationInstanceByHandleL(

        const TInt aDestinationHandle )

    {

    OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYHANDLEL_ENTRY );

    return (CCmmDestinationInstance*)iDestinationObjects->AtL( aDestinationHandle );

    }

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

// Finds a destination instance that belongs to this session and matches

// the provided ID. Return NULL if no match is found.

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

//

CCmmDestinationInstance* CCmmSession::FindDestinationInstanceById(

        const TUint32 aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMSESSION_FINDDESTINATIONINSTANCEBYID_ENTRY );

    CCmmDestinationInstance* wantedDestinationInstance( NULL );

    for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

        {

        CCmmDestinationInstance* destinationInstance =

                ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

        if ( destinationInstance && destinationInstance->GetId() == aDestinationId )

            {

            wantedDestinationInstance = destinationInstance;

            break;

            }

        }

    OstTraceFunctionExit0( CCMMSESSION_FINDDESTINATIONINSTANCEBYID_EXIT );

    return wantedDestinationInstance;

    }

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

// Check from all open destination handles in this session if the given

// connection method is inside any of them. The given destination is skipped.

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

//

TBool CCmmSession::ConnMethodInOtherDestination(

        const TUint32 aConnMethodId,

        const TUint32 aDestinationId )

    {

    OstTraceFunctionEntry0( CCMMSESSION_CONNMETHODINOTHERDESTINATION_ENTRY );

    for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

        {

        CCmmDestinationInstance* destinationInstance =

                ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

        if ( destinationInstance && destinationInstance->GetId() != aDestinationId )

            {

            for ( TInt j = 0; j < destinationInstance->iConnMethodItemArray.Count(); j++ )

                {

                if ( destinationInstance->iConnMethodItemArray[i].iId == aConnMethodId )

                    {

                    OstTraceFunctionExit0( CCMMSESSION_CONNMETHODINOTHERDESTINATION_EXIT );

                    return ETrue;

                    }

                }

            }

        }

    OstTraceFunctionExit0( DUP1_CCMMSESSION_CONNMETHODINOTHERDESTINATION_EXIT );

    return EFalse;

    }

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

// Check for restrictions for adding an embedded destination from destination

// instances of all clients.

// - aDestinationId is the ID of the destination where a destination is beeing

//   embedded.

// - aEmbeddedDestinationId is the ID of the destination that is beeing

//   embedded.

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

//

TBool CCmmSession::EmbeddedDestinationConflictsFromAllSessions(

        const TUint32 aDestinationId,

        const TUint32 aEmbeddedDestinationId )

    {

    OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTSFROMALLSESSIONS_ENTRY );

    return iServer.EmbeddedDestinationConflictsFromAllSessions(

            aDestinationId,

            aEmbeddedDestinationId );

    }

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

// Check for restrictions for adding an embedded destination from destination

// instances of this session.

// - aDestinationId is the ID of the destination where a destination is beeing

//   embedded.

// - aEmbeddedDestinationId is the ID of the destination that is beeing

//   embedded.

//

// - Check that any destination instance does not contain aDestinationId as

//   embedded destination.

// - Check that any destination instance for aEmbeddedDestinationId does not

//   contain an embedded destination.

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

//

TBool CCmmSession::EmbeddedDestinationConflicts(

        const TUint32 aDestinationId,

        const TUint32 aEmbeddedDestinationId )

    {

    OstTraceFunctionEntry0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTS_ENTRY );

    TBool result( EFalse );

    for ( TInt i = 0; i < iDestinationObjects->Count(); i++ )

        {

        CCmmDestinationInstance* destinationInstance =

                ( CCmmDestinationInstance* )( ( *iDestinationObjects )[i] );

        if ( destinationInstance )

            {

            if ( destinationInstance->HasEmbeddedWithId( aDestinationId ) ||

                    ( destinationInstance->GetId() == aEmbeddedDestinationId &&

                            destinationInstance->HasEmbedded() ) )

                {

                result = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMSESSION_EMBEDDEDDESTINATIONCONFLICTS_EXIT );

    return result;

    }

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

// After update to database, refresh temporary ID to real ID if necessary and

// refresh status information for any related handles for all client sessions.

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

//

void CCmmSession::RefreshHandlesForAllSessions( const TCmmIdStruct& aIdStruct )

    {

    OstTraceFunctionEntry0( CCMMSESSION_REFRESHHANDLESFORALLSESSIONS_ENTRY );

    // If the ID structure contains a temporary ID, we need to update the

    // temporary ID to the real ID for all relevant handles in this session and

    // cache.

    if ( aIdStruct.iTemporaryId )

        {

        // Real ID tells if this is a destination or connection method.

        if ( aIdStruct.iRealId < KCmmConnMethodIdIntervalMax )

            {

            // Connection method. Need to iterate through all destination and

            // connection method handles.

            // Update the ID of the connection method on session side.

            for ( TInt i = 0; i < iConnMethodObjects->Count(); i++ )

                {