/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

// INCLUDE FILES

#include "cmmpacketservicemesshandler.h"

#include "cmmnetmesshandler.h"

#include "cmmmessagerouter.h"

#include "cmmstaticutility.h"

#include "tsylogger.h"

#include <in_sock.h>

#include <tisi.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <gpdsisi.h>

#include <pcktcs.h>

#include <gpds_sharedisi.h>

#include <ctsy/serviceapi/gsmerror.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmpacketservicemesshandlerTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    //None

// EXTERNAL FUNCTION PROTOTYPES

    //None

// CONSTANTS

const TUint8 KSetAlwaysOnMode = 0x12;

// MACROS

    //None

// LOCAL CONSTANTS AND MACROS

    //None

// MODULE DATA STRUCTURES

    //None

// LOCAL FUNCTION PROTOTYPES

    //None

// FORWARD DECLARATIONS

    //None

// ==================== LOCAL FUNCTIONS =======================================

    //None

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

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

// CMmPacketServiceMessHandler::CMmPacketServiceMessHandler

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

// might leave.

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

//

CMmPacketServiceMessHandler::CMmPacketServiceMessHandler()

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::C++ constructor");

    }

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

// CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler

// Destructor, deletes all allocated resources.

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

//

CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler()

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::~CMmPacketServiceMessHandler.\n" );

    // Delete iPacketMesshandlerContextList object

    if ( iPacketMesshandlerContextList )

        {

        delete iPacketMesshandlerContextList;

        }

    }

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

// CMmPacketServiceMessHandler::NewL

// Two-phased constructor.

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

//

CMmPacketServiceMessHandler* CMmPacketServiceMessHandler::NewL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver,

    CMmMessageRouter* aMessageRouter )

    {

TFLOGSTRING("TSY: CMmPacketServiceMessHandler::NewL" );

    CMmPacketServiceMessHandler* packetServiceMessHandler =

        new( ELeave ) CMmPacketServiceMessHandler();

    CleanupStack::PushL( packetServiceMessHandler );

    packetServiceMessHandler->iPhoNetSender = aPhoNetSender;

    packetServiceMessHandler->iMessageRouter = aMessageRouter;

    packetServiceMessHandler->ConstructL();

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_GPDS );

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_MODEM_NETWORK,

        NET_MODEM_REG_STATUS_GET_RESP );

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_MODEM_NETWORK,

        NET_MODEM_REG_STATUS_IND );

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_MODEM_NETWORK,

        NET_RAT_IND );

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_MODEM_NETWORK,

        NET_RAT_RESP );

    aPhoNetReceiver->RegisterL(

        packetServiceMessHandler,

        PN_MODEM_NETWORK,

        NET_RADIO_INFO_IND );

    CleanupStack::Pop( packetServiceMessHandler );

    return packetServiceMessHandler;

    }

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

// CMmPacketServiceMessHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmPacketServiceMessHandler::ConstructL()

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::ConstructL");

    iAlwaysOnMode = RMmCustomAPI::EAlwaysModeNeither;

    iPacketMesshandlerContextList = CMmPacketContextMesshandlerList::NewL();

    }

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

// CMmPacketServiceMessHandler::ExtFuncL

// Entry point for messages received from Symbian OS layer (Message manager)

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

//

TInt CMmPacketServiceMessHandler::ExtFuncL(

    TInt aIpc,

    const CMmDataPackage* aDataPackage )

    {

    TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::ExtFuncL. IPC: %d", aIpc );

    TInt ret( KErrNotSupported );

    CMmDataPackage dataPackage;

    switch ( aIpc )

        {

        case EPacketNotifyContextAdded:

            {

            // DO NOTHING

            break;

            }

        case EPacketAttach:

            {

            ret = GpdsAttachReq();

            break;

            }

        case EPacketDetach:

            {

            ret = GpdsDetachReq();

            break;

            }

        case EPacketRejectActivationRequest:

            {

            ret = GpdsContextNwiActRejectReq();

            break;

            }

        case EPacketGetNtwkRegStatus:

            {

            ret = NetModemRegStatusGetReq();

            break;

            }

        case EPacketSetPrefBearer:

            {

            ret = SetPreferredBearer( *aDataPackage );

            break;

            }

        case EPacketSetAttachMode:

            {

            RPacketService::TAttachMode* dataPtr = NULL;

            aDataPackage->UnPackData ( &dataPtr );

            ret = SetAttachMode( dataPtr );

            break;

            }

        case EPacketGetAttachMode:

            {

            TBool calledOnInitPhase;

            aDataPackage->UnPackData( calledOnInitPhase );

            ret = GpdsConfigurationInfoReq( calledOnInitPhase );

            break;

            }

        case EPacketSetDefaultContextParams:

            {

            ret = SetDefaultContextParams( *aDataPackage );

            break;

            }

        case EPacketNotifyStatusChange:

            {

            ret = GpdsStatusReq();

            break;

            }

        case EPacketInitProxiesIPC:

            {

            ret = KMmPacketContextProxy1_DOS;

            break;

            }

        case ECustomSetAlwaysOnMode:

            {

            RMmCustomAPI::TSetAlwaysOnMode alwaysOnMode;

            aDataPackage->UnPackData( alwaysOnMode );

            ret = GpdsConfigureReq(

                KSetAlwaysOnMode,

                GPDS_ATTACH_MODE_DEFAULT,

                GPDS_MT_ACT_MODE_ACCEPT,

                GPDS_CLASSC_MODE_DEFAULT,

                alwaysOnMode );

            break;

            }

        default:

            {

            TFLOGSTRING2("TSY: CMmPacketServiceMessHandler::ExtFuncL - Unknown IPC: %d",  aIpc);

            break;

            }

        }

    return ret;

    }

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

// CMmPacketServiceMessHandler::ReceiveMessageL

// Entry point for messages received from Domestic OS.

// Switches the message to the correct method.

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

//

void CMmPacketServiceMessHandler::ReceiveMessageL(

    const TIsiReceiveC &aIsiMessage )

    {

    TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

    TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::ReceiveMessageL. resource:%d, msgId:%d", resource, messageId);

    switch ( resource )

        {

        case PN_MODEM_NETWORK:

            {

            switch ( messageId )

                {

                case NET_MODEM_REG_STATUS_GET_RESP:

                case NET_MODEM_REG_STATUS_IND:

                    {

                    NetModemRegStatusGetRespOrInd( aIsiMessage );

                    break;

                    }

                case NET_RAT_IND:

                case NET_RAT_RESP:

                    {

                    NetRatIndOrResp( aIsiMessage );

                    break;

                    }

                case NET_RADIO_INFO_IND:

                    {

                    NetRadioInfoInd( aIsiMessage );

                    break;

                    }

                default:

                    {

TFLOGSTRING("TSY: CMmPacketServiceMessHandler::ReceiveMessageL. default in case PN_MODEM_NETWORK");

                    break;

                    }

                }

            break;

            }

        case PN_GPDS:

            {

            switch ( messageId )

                {

                case GPDS_CONTEXT_ID_CREATE_IND:

                    {

                    GpdsContextIdCreateInd( aIsiMessage );

                    break;

                    }

                case GPDS_CONFIGURATION_INFO_RESP:

                    {

                    GpdsConfigurationInfoResp( aIsiMessage );

                    break;

                    }

                case GPDS_CONFIGURATION_INFO_IND:

                    {

                    GpdsConfigurationInfoInd( aIsiMessage );

                    break;

                    }

                case GPDS_TRANSFER_STATUS_IND:

                    {

                    GpdsTransferStatusInd( aIsiMessage );

                    break;

                    }

                case GPDS_CONFIGURE_RESP:

                    {

                    GpdsConfigureResp( aIsiMessage );

                    break;

                    }

                case GPDS_STATUS_RESP:

                    {

                    GpdsStatusResp( aIsiMessage );

                    break;

                    }

                case GPDS_ATTACH_RESP:

                    {

                    GpdsAttachResp( aIsiMessage );

                    break;

                    }

                case GPDS_ATTACH_IND:

                    {

                    GpdsAttachInd();

                    break;

                    }

                case GPDS_DETACH_RESP:

                    {

                    GpdsDetachResp( aIsiMessage );

                    break;

                    }

                case GPDS_DETACH_IND:

                    {

                    GpdsDetachInd();

                    break;

                    }

                case GPDS_CONTEXT_NWI_ACT_REQUEST_IND:

                    {

                    GpdsContextNwiActRequestInd( aIsiMessage );

                    break;

                    }

                case GPDS_CONTEXT_NWI_ACT_REJECT_RESP:

                    {

                    GpdsContextNwiActRejectResp( aIsiMessage );

                    break;

                    }

                case GPDS_CONTEXT_CONFIGURE_RESP:

                    {

                    GpdsContextConfigureResp( aIsiMessage );

                    break;

                    }

                default:

                    {

TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SpecificPacketServiceMessageReceived: KErrNotFound");

                    break;

                    }

                }

            break;

            }

        default:

            {

            // No appropriate handler methods for ISI-message found.

TFLOGSTRING("TSY: CMmPacketServiceMessHandler::SpecificPacketServiceMessageReceived no handler for the message id");

            // server not known

            break;

            }

        }

    }

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

// CMmPacketServiceMessHandler::GpdsStatusReq

// Constructs GPDS_STATUS_REQ ISI message and sends it to Phonet

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

//

TInt CMmPacketServiceMessHandler::GpdsStatusReq() const

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsStatusReq.\n" );

    // Append data for ISI message

    TBuf8<KBuffSizeOneByte> data;

    // Message sent via Phonet

    // Transaction id ( 0xDD - KDummyTrIdDD ) is not needed to store, dummy is enough

    // create gpds status request

    return iPhoNetSender->Send( PN_GPDS, KDummyTrIdDD, GPDS_STATUS_REQ, data );

    }

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

// CMmPacketServiceMessHandler::GpdsStatusResp

// Breaks a GPDS_STATUS_RESP ISI message

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

//

void CMmPacketServiceMessHandler::GpdsStatusResp(

    const TIsiReceiveC& aIsiMessage )

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsStatusResp.\n" );

    const TUint8 attachStatus( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + GPDS_STATUS_RESP_OFFSET_ATTACHSTATUS ) );

    const TUint8 transfStatus( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + GPDS_STATUS_RESP_OFFSET_TRANSFERSTATUS ) );

    TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::GpdsStatusResp.\n  \t Attach Status:%d\n\t Transfer Status:%d\n", attachStatus, transfStatus );

    CompleteGpdsStatusRequest( attachStatus, transfStatus );

    }

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

// CMmPacketServiceMessHandler::GpdsAttachReq

// Constructs GPDS_ATTACH_REQ ISI message and sends it to Phonet.

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

//

TInt CMmPacketServiceMessHandler::GpdsAttachReq() const

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachReq.\n" );

    // Append data for ISI message

    TBuf8<1> data;

    data.Append( GPDS_FOLLOW_OFF );

    // Message sent via Phonet

    return iPhoNetSender->Send(

        PN_GPDS, GPDS_ATTACH_REQ, GPDS_ATTACH_REQ, data );

    }

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

// CMmPacketServiceMessHandler::GpdsAttachResp

// Breaks a GPDS_ATTACH_RESP ISI message

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

//

void CMmPacketServiceMessHandler::GpdsAttachResp(

    const TIsiReceiveC& aIsiMessage ) const

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachResp.\n" );

    if ( GPDS_ATTACH_REQ == aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_UTID ) )

        {

        const TUint8 status( aIsiMessage.Get8bit(

            ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_STATUS ) );

        const TUint8 cause( aIsiMessage.Get8bit(

            ISI_HEADER_SIZE + GPDS_ATTACH_RESP_OFFSET_CAUSE ) );

        TInt errorValue( KErrNone );

        if ( GPDS_OK != status )

            {

            // Map CS error code to EPOC error code

            errorValue = CMmStaticUtility::PacketDataCSCauseToEpocError(

                cause );

            }

        //no else

        TFLOGSTRING3("TSY: CMmPacketServiceMessHandler::GpdsAttachResp.\n  \t Status:%d\n\t Cause:%d\n", status, cause );

        //Complete Attach

        iMessageRouter->Complete(

            EPacketAttach,

            errorValue );

        }

     //no else

    }

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

// CMmPacketServiceMessHandler::GpdsAttachInd

// Breaks a GPDS_ATTACH_IND ISI message

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

//

void CMmPacketServiceMessHandler::GpdsAttachInd() const

    {

    TFLOGSTRING("TSY: CMmPacketServiceMessHandler::GpdsAttachInd.\n" );

    RPacketService::TStatus status( RPacketService::EStatusAttached );

    TBool isResumed( EFalse );

    CMmDataPackage data;

    data.PackData( &status, &isResumed );