/*

* Copyright (c) 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:  Implementation of internet access point handling.

*

*/

// INCLUDE FILES

#include "HtiMessagesServicePlugin.h"

#include "HtiIAPHandler.h"

#include <HtiDispatcherInterface.h>

#include <cmconnectionmethodext.h>

#include <cmconnectionmethoddef.h>

#include <cmdestinationext.h>

#include <cmmanagerext.h>

#include <cmplugincsddef.h>

#include <cmpluginhscsddef.h>

#include <cmpluginpacketdatadef.h>

#include <cmpluginwlandef.h>

using namespace CMManager;

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMinCreateMsgLength = 5;

const TInt KMinDeleteMsgLength = 3;

const TInt KMinCreateDestMsgLength = 3;

const TInt KMinDeleteDestMsgLength = 3;

const TInt KMinModifyDestMsgLength = 5;

const TInt KMinSetDefConMsgLength = 3;

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8( KErrorInvalidParameters, "Invalid command parameters" );

_LIT8( KErrorCreateFailed, "Access Point creation failed" );

_LIT8( KErrorDeleteFailed, "Access Point deletion failed" );

_LIT8( KErrorDestCreateFailed, "Destination creation failed" );

_LIT8( KErrorDestDeleteFailed, "Destination deletion failed" );

_LIT8( KErrorApAlreadyExists, "Access Point with same name already exists" );

_LIT8( KErrorApNotFound, "Access Point with given name not found" );

_LIT8( KErrorConnCloseFailed,

           "Failed to close a connection using the Access Point" );

_LIT8( KErrorAddToDestFailed, "Adding to destination failed" );

_LIT8( KErrorRemoveFromDestFailed, "Removing from destination failed" );

_LIT8( KErrorDestNotFound, "Destination with given name not found" );

_LIT8( KErrorSetDefConFailed, "Setting default connection failed" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiIAPHandler::NewL

// Two-phased constructor.

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

CHtiIAPHandler* CHtiIAPHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::NewL" );

    CHtiIAPHandler* self = new (ELeave) CHtiIAPHandler();

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::NewL" );

    return self;

    }

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

// CHtiIAPHandler::CHtiIAPHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

CHtiIAPHandler::CHtiIAPHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::CHtiIAPHandler" );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::CHtiIAPHandler" );

    }

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

// CHtiIAPHandler::~CHtiIAPHandler

// Destructor.

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

CHtiIAPHandler::~CHtiIAPHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::~CHtiIAPHandler" );

    for ( TInt i = 0; i < iFields.Count(); i++ )

        {

        delete iFields[i].iData;

        }

    iFields.Reset();

    iFields.Close();

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::~CHtiIAPHandler" );

    }

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

// CHtiIAPHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiIAPHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::ConstructL" );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ConstructL" );

    }

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

// CHtiIAPHandler::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiIAPHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SetDispatcher" );

    }

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

// CHtiIAPHandler::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiIAPHandler::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::ProcessMessageL" );

    for ( TInt i = 0; i < iFields.Count(); i++ )

        delete iFields[i].iData;

    iFields.Reset();

    iFields.Close();

    iConnName.Zero();

    iBearerType = 0;

    // Zero length message and command code validity already checked

    // in HtiMessagesServicePlugin.

    if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateIAP )

        {

        if ( aMessage.Length() < KMinCreateMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleCreateIapL( aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorCreateFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteIAP )

        {

        if ( aMessage.Length() < KMinDeleteMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleDeleteIapL( aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorDeleteFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateDestination )

        {

        if ( aMessage.Length() < KMinCreateDestMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleCreateDestinationL( aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorDestCreateFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteDestination )

        {

        if ( aMessage.Length() < KMinDeleteDestMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleDeleteDestinationL( aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorDestDeleteFailed );

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination ||

            aMessage[0] == CHtiMessagesServicePlugin::ERemoveFromDestination )

        {

        if ( aMessage.Length() < KMinModifyDestMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, ModifyDestinationL( aMessage[0], aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination )

                    {

                    SendErrorMessageL( err, KErrorAddToDestFailed );

                    }

                else

                    {

                    SendErrorMessageL( err, KErrorRemoveFromDestFailed );

                    }

                }

            }

        }

    else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetDefaultConnection )

        {

        if ( aMessage.Length() < KMinSetDefConMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, SetDefaultConnectionL( aMessage.Mid( 1 ) ) );

            if ( err != KErrNone )

                {

                SendErrorMessageL( err, KErrorSetDefConFailed );

                }

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ProcessMessageL" );

    }

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

// CHtiIAPHandler::HandleCreateIapL

// Creates new Internet Access Point.

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

void CHtiIAPHandler::HandleCreateIapL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateIapL" );

    TRAPD( err, ParseCreateMessageL( aData ) );

    if ( err != KErrNone )

        {

        SendErrorMessageL( err, KErrorInvalidParameters );

        return;

        }

    if ( GetAccessPointUIDL() != KErrNotFound )

        {

        SendErrorMessageL( KErrAlreadyExists, KErrorApAlreadyExists );

        return;

        }

    MapLegacyFieldIDs();

    ResolveFieldDataTypes();

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    RCmConnectionMethodExt cm = cmManager.CreateConnectionMethodL( iBearerType );

    CleanupClosePushL( cm );

    HTI_LOG_TEXT( "Connection method created" );

    cm.SetStringAttributeL( ECmName, iConnName );

    HTI_LOG_TEXT( "Name set" );

    TUint32 requestedSeamlessness = 1; // default

    // Set attributes

    HTI_LOG_FORMAT( "Fields to write: %d", iFields.Count() );

    for ( TInt i = 0; i < iFields.Count(); i++ )

        {

        if ( err != KErrNone ) break;

        HTI_LOG_FORMAT( "Writing field %d", ( i + 1 ) );

        TApField field = iFields[i];

        HTI_LOG_FORMAT( "Field ID = %d", field.iId );

        switch ( field.iDataType )

            {

            case EDataTypeText:

                {

                TRAP( err, cm.SetStringAttributeL( field.iId, *field.iData ) );

                break;

                }

            case EDataTypeBool:

                {

                TLex lex( *field.iData );

                TInt result = 0;

                lex.Val( result );

                TRAP( err, cm.SetBoolAttributeL( field.iId, ( TBool ) result ) );

                break;

                }

            case EDataTypeUint:

                {

                TLex lex( *field.iData );

                TUint32 result;

                err = lex.Val( result, EDecimal );

                if ( err == KErrNone )

                    TRAP( err, cm.SetIntAttributeL( field.iId, result ) );

                if ( field.iId == ECmSeamlessnessLevel )

                    requestedSeamlessness = result;

                break;

                }

            case EDataTypeText8:

                {

                HBufC8* buf8 = HBufC8::NewL( field.iData->Length() );

                buf8->Des().Copy( *field.iData );

                TRAP( err, cm.SetString8AttributeL( field.iId, *buf8 ) );

                delete buf8;

                buf8 = NULL;

                break;

                }

            default:

                {

                HTI_LOG_FORMAT( "Unsupported field type %d", field.iDataType );

                err = KErrNotSupported;

                break;

                }

            }

        }

    if ( err != KErrNone )

        {

        HTI_LOG_FORMAT( "Error occurred %d", err );

        User::Leave( err );

        }

    cm.UpdateL();

    TUint32 uid = cm.GetIntAttributeL( ECmId );

    CleanupStack::PopAndDestroy(); // cm

    // The seamlessness value is not always set correctly when the connection

    // method is created. Have to update seamlessness value separately after

    // creation.

    cm = cmManager.ConnectionMethodL( uid );

    CleanupClosePushL( cm );

    TUint32 currentSeamlessness = cm.GetIntAttributeL( ECmSeamlessnessLevel );

    HTI_LOG_FORMAT( "Requested seamlessness = %d", requestedSeamlessness );

    HTI_LOG_FORMAT( "Current seamlessness = %d", currentSeamlessness );

    if ( currentSeamlessness != requestedSeamlessness )

        {

        cm.SetIntAttributeL( ECmSeamlessnessLevel, requestedSeamlessness );

        cm.UpdateL();

        HTI_LOG_TEXT( "Seamlessness value updated" );

        }

    CleanupStack::PopAndDestroy(); // cm

    CleanupStack::PopAndDestroy(); // cmManager

    HTI_LOG_FORMAT( "AP created with uid %d", uid );

    TBuf8<4> idBuf;

    idBuf.Append( ( TUint8* ) &uid, 4 );

    SendOkMsgL( idBuf );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateIapL" );

    }

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

// CHtiIAPHandler::HandleDeleteIapL

// Deletes the named Internet Access Point

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

void CHtiIAPHandler::HandleDeleteIapL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteIapL" );

    if ( aData.Length() < KMinDeleteMsgLength )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    TInt nameLength = aData[0];

    if ( nameLength > KMaxConnNameLength ||

         aData.Length() != ( nameLength + 1 ) )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    iConnName.Copy( aData.Mid( 1, nameLength ) );

    HTI_LOG_FORMAT( "Searching connection with name: %S", &iConnName );

    TInt uid = GetAccessPointUIDL();

    if ( uid == KErrNotFound )

        {

        SendErrorMessageL( KErrNotFound, KErrorApNotFound );

        return;

        }

    RCmManagerExt cmManagerExt;

    cmManagerExt.OpenL();

    CleanupClosePushL( cmManagerExt );

    RCmConnectionMethodExt connMethod = cmManagerExt.ConnectionMethodL( uid );

    CleanupClosePushL( connMethod );

    if ( connMethod.GetBoolAttributeL( ECmConnected ) )

        {

        HTI_LOG_TEXT( "AP in use - trying to close connections" );

        TRAPD( err, CloseActiveConnectionsL() );

        if ( err != KErrNone )

            {

            SendErrorMessageL( err, KErrorConnCloseFailed );

            CleanupStack::PopAndDestroy( 2 ); // connMethod, cmManagerExt

            return;

            }

        }

    HTI_LOG_TEXT( "AP not in use - unlinking from all destinations" );

    cmManagerExt.RemoveAllReferencesL( connMethod );

    HTI_LOG_TEXT( "Deleting the AP" );

    TBool deleted = connMethod.DeleteL(); // returns ETrue if really deleted

    if ( !deleted )

        {

        HTI_LOG_TEXT( "Delete failed" );

        User::Leave( KErrGeneral );

        }

    HTI_LOG_FORMAT( "AP deleted with uid %d", uid );

    CleanupStack::PopAndDestroy(); // connMethod

    CleanupStack::PopAndDestroy(); // cmManagerExt

    SendOkMsgL( KNullDesC8 );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteIapL" );

    }

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

// CHtiIAPHandler::HandleCreateDestinationL

// Creates a new Destination.

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

void CHtiIAPHandler::HandleCreateDestinationL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateDestinationL" );

    TInt nameLength = aData[0];

    if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    iDestName.Copy( aData.Mid( 1 ) );

    RCmDestinationExt dest = cmManager.CreateDestinationL( iDestName );

    CleanupClosePushL( dest );

    dest.UpdateL();

    CleanupStack::PopAndDestroy( 2 ); // dest, cmManager

    SendOkMsgL( KNullDesC8 );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateDestinationL" );

    }

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

// CHtiIAPHandler::HandleDeleteDestinationL

// Deletes a named Destination.

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

void CHtiIAPHandler::HandleDeleteDestinationL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteDestinationL" );

    TInt nameLength = aData[0];

    if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    iDestName.Copy( aData.Mid( 1 ) );

    TInt id = GetDestinationIDL( iDestName );

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    RCmDestinationExt dest = cmManager.DestinationL ( id );

    dest.DeleteLD();

    CleanupStack::PopAndDestroy(); // cmManager

    SendOkMsgL( KNullDesC8 );

    HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteDestinationL" );

    }