/*

* Copyright (c) 2006-2008 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:  Message handler context class implementation.

*

*/

#include <e32base.h>

#include <s32mem.h>

#include <e32cmn.h>

#include <cfcontextsourcecommand.h>

#include "CFMessageHandlerContext.h"

#include "CFContextObjectImpl.h"

#include "cfextendedcontextinterface.h"

#include "CFScriptInterface.h"

#include "CFContextSubscriptionImpl.h"

#include "cfcontextindication.h"

#include "CFContextIndicationImpl.h"

#include "CFServSession.h"

#include "CFContextQueryImpl.h"

#include "cfcommon.h"

#include "cftrace.h"

#include "CFContextDataProxy.h"

#include "cfserviceutils.h"

// CONSTANTS

#ifdef _DEBUG

LOCAL_C void Panic( const RMessage2& aMessage, TInt aCode )

    {

    CCFServSession::PanicClient( aMessage, aCode );

    }

#endif

// Local function to clean up RContextQueryArray

LOCAL_C void CleanupContextQueryArray( TAny* aArray )

    {

    RContextQueryArray* array = static_cast<RContextQueryArray*>( aArray );

    array->ResetAndDestroy();

    }

// Puts RContextQueryArray in clean up stack

LOCAL_C void CleanupResetAndDestroyPushL( RContextQueryArray& aArray )

    {

    TCleanupItem item( CleanupContextQueryArray, &aArray );

    CleanupStack::PushL( item );

    }

// METHODS

CCFMessageHandlerContext* CCFMessageHandlerContext::NewL(

	MCFExtendedContextInterface& aCFContext,

    MCFActionInterface& aCFAction,

    MCFScriptInterface& aScriptInterface )

    {

    FUNC_LOG;

    CCFMessageHandlerContext* self = CCFMessageHandlerContext::NewLC(

        aCFContext,

        aCFAction,

        aScriptInterface );

    CleanupStack::Pop( self );

    return self;

    }

CCFMessageHandlerContext* CCFMessageHandlerContext::NewLC(

	MCFExtendedContextInterface& aCFContext,

    MCFActionInterface& aCFAction,

    MCFScriptInterface& aScriptInterface )

    {

    FUNC_LOG;

    CCFMessageHandlerContext* self = new( ELeave ) CCFMessageHandlerContext(

        aCFContext,

        aCFAction,

        aScriptInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CCFMessageHandlerContext::~CCFMessageHandlerContext()

    {

    FUNC_LOG;

    // Cancel outsanding request from client

    CancelReceiveContextIndicationMessage();

    // Remove all subscriptions from this session

    iCFContext.UnsubscribeContexts( *this );

    iCFContext.DeregisterPublisher( *this );

    // Clean buffers

    iIndicationQueue.ResetAndDestroy();

    TInt count = iSubscriptionErrors.Count();

    for( TInt i = 0; i < count; i++ )

        {

        delete iSubscriptionErrors[i].iContext;

        }

    // Close arrays which context are not owned

    iContextRequestBuffer.Close();

    }

CCFMessageHandlerContext::CCFMessageHandlerContext(

	MCFExtendedContextInterface& aCFContext,

    MCFActionInterface& aCFAction,

    MCFScriptInterface& aScriptInterface )

    :   CCFMessageHandlerBase( aCFContext, aCFAction, aScriptInterface )

    {

    FUNC_LOG;

    }

void CCFMessageHandlerContext::ConstructL()

    {

    FUNC_LOG;

    }

// METHODS

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

// CCFMessageHandlerContext::HandleMessageL

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

//

TBool CCFMessageHandlerContext::HandleMessageL( const RMessage2& aMessage )

    {

    FUNC_LOG;

    INFO_1( "[MessageHandlerContext] Handling IPC message: %d", aMessage.Function() );

    TBool handled = ETrue;

    switch( aMessage.Function() )

        {

        // Slot[0] = TDesC - CCFContextObject

        case EPublishContext:

            {

            INFO( "Handling IPC message [EPublishContext]" );

            // Stream context from client buffer

            CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

            TInt length = aMessage.GetDesLengthL( 0 );

            HBufC8* buffer = HBufC8::NewLC( length );

            TPtr8 bufferPtr = buffer->Des();

            aMessage.ReadL( 0, bufferPtr );

            RDesReadStream readStream( bufferPtr );

            readStream.PushL();

            context->InternalizeL( readStream );

            // Clean up

            CleanupStack::PopAndDestroy( &readStream );

            CleanupStack::PopAndDestroy( buffer );

            // Send request to CF Engine

            RThread clientThread;

            aMessage.ClientL( clientThread );

            CleanupClosePushL( clientThread );

            TInt err = PublishContext( *context, clientThread );

            // Clean up

            CleanupStack::PopAndDestroy( &clientThread );

            CleanupStack::PopAndDestroy( context );

            // Complete

            aMessage.Complete( err );

            INFO( "Handled IPC message [EPublishContext]" );

            break;

            }

        // Slot[0] = TDesC - CCFContextSubscription

        case EAddSubscription:

            {

            INFO( "Handling IPC message [EAddSubscription]" );

            // Stream subscription from client buffer

            CCFContextSubscriptionImpl* subscription =

                CCFContextSubscriptionImpl::NewLC();

            TInt length = aMessage.GetDesLengthL( 0 );

            HBufC8* buffer = HBufC8::NewLC( length );

            TPtr8 bufferPtr = buffer->Des();

            aMessage.ReadL( 0, bufferPtr );

            RDesReadStream readStream( bufferPtr );

            readStream.PushL();

            subscription->InternalizeL( readStream );

            // Clean up

            CleanupStack::PopAndDestroy( &readStream );

            CleanupStack::PopAndDestroy( buffer );

            // Send request to CF Engine

            RThread clientThread;

            aMessage.ClientL( clientThread );

            CleanupClosePushL( clientThread );

            TInt err = AddSubscription( subscription, clientThread );

            // Clean up

            CleanupStack::PopAndDestroy( &clientThread );

            CleanupStack::Pop( subscription );

            // Handle results            

            if( err != KErrNone )

                {

                // Notify error

                DoHandleContextSubscriptionErrorL( err,

                    subscription->ContextSource(),

                    subscription->ContextType() );

                }

            // Complete

            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [EAddSubscription]" );

            break;

            }

        // Slot[0] = TDesC - CCFContextSubscription

        case ERemoveSubscription:

            {

            INFO( "Handling IPC message [ERemoveSubscription]" );

            // Stream subscription from client buffer

            CCFContextSubscriptionImpl* subscription =

                CCFContextSubscriptionImpl::NewLC();

            TInt length = aMessage.GetDesLengthL( 0 );

            HBufC8* buffer = HBufC8::NewLC( length );

            TPtr8 bufferPtr = buffer->Des();

            aMessage.ReadL( 0, bufferPtr );

            RDesReadStream readStream( bufferPtr );

            readStream.PushL();

            subscription->InternalizeL( readStream );

            // Clean up

            CleanupStack::PopAndDestroy( &readStream );

            CleanupStack::PopAndDestroy( buffer );

            // Send request to CF Engine

            RemoveSubscription( *subscription );

            // Clean up

            CleanupStack::PopAndDestroy( subscription );

            // Complete

            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [ERemoveSubscription]" );

            break;

            }

        // Slot[0] = TDes - Buffer

        // Slot[1] = TPckg<TInt> - Buffer size

        case EReceiveContextIndicationMessage:

            {

            INFO( "Handling IPC message [EReceiveContextIndicationMessage]" );

            ReceiveContextIndicationMessageL( aMessage );

            INFO( "Handled IPC message [EReceiveContextIndicationMessage]" );

            break;

            }

        // Slot[0] = TDes - Buffer

        // Slot[1] = TPckg<TInt> - Buffer size

        case EReceiveMessage:

            {

            INFO( "Handling IPC message [EReceiveMessage]" );

            ReceiveMessageL( aMessage );

            INFO( "Handled IPC message [EReceiveMessage]" );

            break;

            }

        // Slot[0] = TDes - Buffer

        case EGetContextIndication:

            {

            INFO( "Handling IPC message [EGetContextIndication]" );

            // Client has increased buffer size

            // Get next indication from queue

            // Message will be completed in the method

            CompleteNextIndicationFromQueueL( aMessage );

            INFO( "Handled IPC message [EGetContextIndication]" );

            break;

            }

        // Slot[0] = TDes - Buffer

        case EGetMessage:

            {

            INFO( "Handling IPC message [EGetMessage]" );

            // Client has increased buffer size

            // Get next indication from queue

            // Message will be completed in the method

            CompleteNextMessageFromQueueL( aMessage );

            INFO( "Handled IPC message [EGetMessage]" );

            break;

            }

        // No parameters

        case ECancelReceiveContextIndicationMessage:

            {

            INFO( "Handling IPC message [ECancelReceiveContextIndicationMessage]" );

            CancelReceiveContextIndicationMessage();

            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [ECancelReceiveContextIndicationMessage]" );

            break;

            }

        // No parameters

        case ECancelReceiveMessage:

            {

            INFO( "Handling IPC message [ECancelReceiveContextIndicationMessage]" );

            CancelReceiveMessage();

            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [ECancelReceiveContextIndicationMessage]" );

            break;

            }

        // Slot[0] = TDes - Result buffer

        // Slot[1] = TDesC - CCFContextQuery

        // Slot[2] = TPckg<TInt> - Buffer size

        case ERequestContext:

            {

            INFO( "Handling IPC message [ERequestContext]" );

            TInt err = KErrNone;

            // Check if the client has already requested contexts but

            // has failed due too small buffer size

            if( iContextRequestBuffer.Count() )

                {

                // Write request result into client side buffer

                CompleteRequestContextL( aMessage );

                // Reset buffer

                iContextRequestBuffer.Reset();

                }

            else

                {

                // New request

                // Stream query

                CCFContextQueryImpl* query =

                    CCFContextQueryImpl::NewLC( KNullDesC, KNullDesC );

                TInt bufferSize = aMessage.GetDesLengthL( 1 );

                HBufC8* buffer = HBufC8::NewLC( bufferSize );

                TPtr8 bufferPtr = buffer->Des();

                aMessage.ReadL( 1, bufferPtr );

                RDesReadStream readStream( bufferPtr );

                readStream.PushL();

                query->InternalizeL( readStream );

                // Clean up

                CleanupStack::PopAndDestroy( &readStream );

                CleanupStack::PopAndDestroy( buffer );

                // Send request to CF Engine

                RThread clientThread;

                aMessage.ClientL( clientThread );

                CleanupClosePushL( clientThread );

                err = RequestContext( *query, clientThread );

                // Clean up

                CleanupStack::PopAndDestroy( &clientThread );

                CleanupStack::PopAndDestroy( query );

                // Handle request context results

                if( err == KErrNone && iContextRequestBuffer.Count() )

                    {

                    // Write request result into client side buffer if

                    // request succesfull

                    CompleteRequestContextL( aMessage );

                    }

                else

                    {

                    // Complete with error code

                    aMessage.Complete( err );

                    }

                }

            INFO( "Handled IPC message [ERequestContext]" );

            break;

            }

        // Slot[0] = TDes - Result buffer

        // Slot[1] = TDesC - CCFContextQuery

        // Slot[2] = TPckg<TInt> - Buffer size

        case ERequestContextSet:

        	{

            INFO( "Handling IPC message [ERequestContextSet]" );

            TInt err = KErrNone;

            // Check if the client has already requested contexts but

            // has failed due too small buffer size

            if( iContextRequestBuffer.Count() )

                {

                // Write request result into client side buffer

                CompleteRequestContextL( aMessage );

                // Reset buffer

                iContextRequestBuffer.Reset();

                }

            else

                {

                // New request

                // Stream query

                RContextQueryArray queryArray;

                CleanupResetAndDestroyPushL( queryArray );

                TInt bufferSize = aMessage.GetDesLengthL( 1 );

                HBufC8* buffer = HBufC8::NewLC( bufferSize );

                TPtr8 bufferPtr = buffer->Des();

                aMessage.ReadL( 1, bufferPtr );

                RDesReadStream readStream( bufferPtr );

                readStream.PushL();

                TInt count = readStream.ReadInt16L();

                for( TInt i = 0; i < count; i++ )

                    {

                    CCFContextQueryImpl* query =

                        CCFContextQueryImpl::NewLC( KNullDesC, KNullDesC );

                    query->InternalizeL( readStream );

                    queryArray.AppendL( query );

                    CleanupStack::Pop( query );

                    }

                // Clean up

                CleanupStack::PopAndDestroy( &readStream );

                CleanupStack::PopAndDestroy( buffer );

                // Send request to CF Engine

                RThread clientThread;

                aMessage.ClientL( clientThread );

                CleanupClosePushL( clientThread );

                count = queryArray.Count();

                for( TInt i = 0; i < count; i++ )

                    {

                    RequestContext( *queryArray[i], clientThread );

                    }

                // Clean up

                CleanupStack::PopAndDestroy( &clientThread );

                CleanupStack::PopAndDestroy( &queryArray );

                // Handle request context results

                if( err == KErrNone && iContextRequestBuffer.Count() )

                    {

                    // Write request result into client side buffer if

                    // request succesfull

                    CompleteRequestContextL( aMessage );

                    }

                else

                    {

                    // Complete with error code

                    aMessage.Complete( err );

                    }

                }

            INFO( "Handled IPC message [ERequestContextSet]" );

        	break;

        	}

        // Slot[0] = TDesC&

        // Slot[1] = TDesC&

        // Slot[2] = TSecurityPolicyBuf - read policy

        // Slot[3] = TSecurityPolicyBuf - write policy

        case EDefineContext:

            {

            INFO( "Handling IPC message [EDefineContext]" );

            TInt err = KErrNone;

            // Read context source

            HBufC* contextSource = HBufC::NewLC( aMessage.GetDesLengthL( 0 ) );

            TPtr contextSourcePtr = contextSource->Des();

            aMessage.ReadL( 0, contextSourcePtr );

            // Read context type

            HBufC* contextType = HBufC::NewLC( aMessage.GetDesLengthL( 1 ) );

            TPtr contextTypePtr = contextType->Des();

            aMessage.ReadL( 1, contextTypePtr );

            // Read security policy

            TSecurityPolicyBuf readSecPolicyBuf;

            aMessage.ReadL( 2, readSecPolicyBuf );

            TSecurityPolicy readSecPolicy;

            User::LeaveIfError( readSecPolicy.Set( readSecPolicyBuf ) ); // verifies the security policy

            TSecurityPolicyBuf writeSecPolicyBuf;

            aMessage.ReadL( 3, writeSecPolicyBuf );

            TSecurityPolicy writeSecPolicy;

            User::LeaveIfError( writeSecPolicy.Set( writeSecPolicyBuf ) ); // verifies the security policy

            RThread clientThread;

            aMessage.ClientL( clientThread );