/*

* Copyright (c) 2002-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:  GPRS Data channel for BIP

*

*/

#include <etelqos.h>

#include <cmmanager.h>

#include <cmconnectionmethod.h>

#include <cmpluginpacketdatadef.h>

#include <cs_subconevents.h>                    // For subconnection events

#include <networking/qos3gpp_subconparams.h>    // For extension parameters

#include <e32std.h>                             // TRealFormat

#include <e32cmn.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <in_sock_internal.h>                   // For KSoUdpRecvBuf contant

#endif

#include "CSatBIPUtils.h"

#include "CSatBIPGPRSDataChannel.h"

#include "SatLog.h"

#include "EnginePanic.h"

#include "CSatBIPDataSender.h"

#include "CSatBIPDataReceiver.h"

#include "MSatSendDataObserver.h"

#include "MSatConnectionObserver.h"

#include "TSatChannelIDInfo.h"

#include "TSatQoSParser.h"

#include "csatbipsubconneventobserver.h"

#include "csatsactivewrapper.h"

// Required GPRS parameters

const TUint8 KReqGprsQoSParams = 6;

// Required packet protocol type is always 02 for GPRS -> IP Protocol

const TUint8 KReqPacketProtType = 0x02;

// Position of the protocol type in the array

const TUint8 KProtocolPos = 5;

// Lengths of IP address

const TUint8 KIPv4Length = 4;

const TUint8 KIPv6Length = 16;

#ifdef SAT_USE_DUMMY_TSY

const TUint8 KIpAddressSize( 15 );

const TUint8 KIpv4Length( 4 );

const TUint8 KIpv6Length( 16 );

const TUint8 KIpAddressA( 0 );

const TUint KIpAddressAValue( 127 );

const TUint8 KIpAddressB( 1 );

const TUint KIpAddressBValue( 0 );

const TUint8 KIpAddressC( 2 );

const TUint KIpAddressCValue( 0 );

const TUint8 KIpAddressD( 3 );

const TUint KIpAddressDValueDestination( 2 );

const TUint KIpAddressDValueLocal( 3 );

#endif

#ifdef ENABLE_SAT_LOGGING

const TUint8 KIpAddressLogSize( 40 );

#endif

const TInt KReCheckStatusDelay = 100000; // 100ms

const TInt KMaxAttempts = 20;            // 20*100ms= 2s 

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

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

// Two-phased constructor.

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

//

CSatBIPGPRSDataChannel* CSatBIPGPRSDataChannel::NewL(

    CSatBIPUtils& aUtils,

    RSocketServ& aSocketServer,

    TSatChannelIdInfo& aChannelId,

    RConnection& aConnection,

    RSubConnection& aSubConnection )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::NewL calling" )

    CSatBIPGPRSDataChannel* self = new( ELeave ) CSatBIPGPRSDataChannel( 

        aUtils, aSocketServer, aChannelId, aConnection, aSubConnection );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::NewL exiting" )

    return self;

    }

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

// Two-phased constructor.

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

//

CSatBIPGPRSDataChannel* CSatBIPGPRSDataChannel::NewLC(

    CSatBIPUtils& aUtils,

    RSocketServ& aSocketServer,

    TSatChannelIdInfo& aChannelId,

    RConnection& aConnection,

    RSubConnection& aSubConnection )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::NewLC calling" )

    CSatBIPGPRSDataChannel* self = new ( ELeave ) CSatBIPGPRSDataChannel( 

        aUtils, aSocketServer, aChannelId, aConnection, aSubConnection );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::NewLC exiting" )

    return self;

    }

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

// destructor.

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

//

CSatBIPGPRSDataChannel::~CSatBIPGPRSDataChannel()

    {

    LOG( SIMPLE,

         "SATENGINE: CSatBIPGPRSDataChannel::~CSatBIPGPRSDataChannel calling" )

    // Close sender

    delete iSender;

    // Close receiver

    delete iReceiver;

    // Close receiver

    delete iSubConnEventObserver;

    // Close Socket

    iSocket.Close();

    // Delete buffers

    delete iSendStore;

    iRcvBuffer.Zero();

    LOG( SIMPLE,

         "SATENGINE: CSatBIPGPRSDataChannel::~CSatBIPGPRSDataChannel exiting" )

    }

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

// Sets up connection

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

//

void CSatBIPGPRSDataChannel::SetupConnectionL( 

    const TSatBipConnectionInfo& aConnParams )

    {

    LOG( SIMPLE, 

        "SATENGINE: CSatBIPGPRSDataChannel::SetupConnectionL calling" )

    // Allocate Send buffer

    iSendStore = HBufC8::NewL( aConnParams.iBufferSize );

    // Store the rest of connection information

    iConnInfo = aConnParams;

    // Define used protocol

    iUseTcpProtocol = ( RSat::ETcp == iConnInfo.iProtocol.iTransportProto );

    // Set connection stage

    iConnStage = ESatBIPClosed;

    LOG( SIMPLE, 

        "SATENGINE: CSatBIPGPRSDataChannel::SetupConnectionL exiting" )

    }

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

// Opens the connection

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

//

void CSatBIPGPRSDataChannel::ActivateConnectionL(

    MSatConnectionObserver* aObserver )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL calling" )

    TInt errCode( KErrNone );               // errCode

    RPacketQoS::TQoSGPRSNegotiated negQoS;  // The negotiated QoS

    // If the connection has not been setup or already connecting, leave

    if ( ESatBIPClosed != iConnStage )

        {

        LOG( SIMPLE,

        "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL \

        ESatBIPClosed != iConnStage" )

        User::Leave( KErrCancel );

        }

    iConnectionObserver = aObserver;

    if ( RSat::EIPv4Address == iConnInfo.iDestination.iType )

        {

        LOG( NORMAL, 

             "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

             Using IPv4" )

        }

    else if ( RSat::EIPv6Address == iConnInfo.iDestination.iType )

        {

        LOG( NORMAL, 

             "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

             Using IPv6" )

        }

    else

        {

        LOG( NORMAL, "  Unknown IP type" )

        User::Leave( KErrUnknown );

        }

    // Open connection if it is inactive

    if ( !iUtils.IsConnectionActivated() )

        {

        LOG( NORMAL, 

             "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

             Connection is inactive, open connection " )

        // Write the primary PDP Context QoS Parameters to CMManager

        // before activating the primary PDP Context.  

        WritePrimaryPDPContextQoSParamsL();

        // Open sub-session to SocketServer    

        errCode = iConnection.Open( iSocketServ );

        LOG2( NORMAL, 

              "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

              RConnection opened with code: %i", errCode )

        User::LeaveIfError( errCode );

        // Start connection. If there are no override settings, 

        // use default settings

        if ( iConnInfo.iOverrideSet )

            {

            LOG( NORMAL, "Starting connection with override settings" )

            TConnPrefList prefList;

            TExtendedConnPref extPrefs;

            extPrefs.SetNoteBehaviour( 

                    iConnInfo.iOverrideSet->NoteBehaviour() );

            extPrefs.SetIapId( iConnInfo.iOverrideSet->IapId() );

            prefList.AppendL( &extPrefs );

            errCode = iConnection.Start( prefList );

            }

        else

            {

            LOG( NORMAL, "Starting connection with default settings" )

            errCode = iConnection.Start();

            }

        LOG2( NORMAL, 

              "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

              RConnection started with code: %i", errCode )

        User::LeaveIfError( errCode );

        // Erase the primary PDP Context QoS Parameters from CMManager 

        WriteDefaultQoSParamsL();

        // Set Connection activated

        iUtils.SetConnectionActivated( ETrue );

        // Make sure the subconnection is inactive.

        iUtils.SetSubConnectionActivated( EFalse );

        }

    else    

        {

        LOG( NORMAL, 

             "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

             Connection is active " )

        // Connection is active, open SubConnection if it is inactive

        if ( !iUtils.IsSubConnectionActivated() ) 

            {

            LOG( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::\

            ActivateConnectionL SubConnection is inactive, open \

            subconnection" )

            // Open SubConnection 

            OpenSubConnection();

            }

        }

    // Set up QoS values

    SetConnQoSParamsL();

    // Open socket

    OpenSocketL();

    // UDP Socket doesn't need ActiveObject, so we don't have to wait.

    if ( !iUseTcpProtocol )

        {

        LOG( NORMAL, 

             "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL\

             UDP protocol " )

        StartReceiveL();

        iConnStage = ESatBIPConnected;

        // Notify ConnectionObserver

        iConnectionObserver->ConnectionNotification( KErrNone );

        }

    LOG( SIMPLE,

        "SATENGINE: CSatBIPGPRSDataChannel::ActivateConnectionL exiting" )

    }

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

// ends or stores the data.

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

//

void CSatBIPGPRSDataChannel::GetNegotiatedQoSParams( 

    RSat::TBearerParams& aResult ) const

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::NegotiatedQoSParams\

        calling - exiting" )

    aResult = iConnInfo.iBearerParams;

    }

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

// Sends or stores the data.

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

//

TInt CSatBIPGPRSDataChannel::SendDataL( const TDes8& aData,

    const TBool aSendImmediately,

    TInt& aFreeBufferSize,

    MSatSendDataObserver* aObserver )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL calling" )

    TInt errCode( MSatBIPUtils::ESatBIPSuccess );

    CSatSActiveWrapper* delay = NULL;

    TInt numberOfTries( 1 );

    // Check status of connection

    TBool suspended( RPacketService::EStatusSuspended == 

        iUtils.ConnectionStatus() );

    // Check that does the data fit in buffer

    const TInt bufsize( iSendStore->Length() );

    LOG2( NORMAL,

        "SATENGINE: CSatBIPGPRSDataChannel::SendDataL iSendBuffer size: %i",

        bufsize )

    LOG2( NORMAL,

        "SATENGINE: CSatBIPGPRSDataChannel::SendDataL aData size: %i",

        aData.Length() )

    if ( suspended )

        {

        // for async wait

        delay = new ( ELeave ) CSatSActiveWrapper();

        }

    while ( suspended && KMaxAttempts >= numberOfTries ) 

        {

        // In cases of SMS or Call suspend the pdp context, we need to 

        // evaluate the status of context after a small delay

        LOG2( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL, wait, %d "\

            , numberOfTries )

        delay->After( KReCheckStatusDelay );

        suspended = RPacketService::EStatusSuspended == iUtils.ConnectionStatus();

        numberOfTries++;

        }

    delete delay;

    delay = NULL;

    if ( suspended && aSendImmediately )

        {

        LOG( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL \

            Connection suspended" )

        errCode = MSatBIPUtils::ESatBIPServiceError;

        }

    else if ( iConnInfo.iBufferSize < ( aData.Length() + bufsize ) )

        {

        LOG( NORMAL,

            "SATENGINE: CSatBIPGPRSDataChannel::SendDataL Buffer overflow" )

        errCode = MSatBIPUtils::ESatBIPReqBufSizeNotAvail;

        }

    else

        {

        // Append data to send buffer

        TPtr8 ptr = iSendStore->Des();

        ptr.Append( aData );

        // Send immediately, if required

        if ( aSendImmediately )

            {

            LOG( NORMAL,

                "SATENGINE: CSatBIPGPRSDataChannel::SendDataL Sending data" )

            // If Sender object is NULL, create it

            if ( !iSender && aObserver )

                {

                LOG( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL \

                create iSender" )

                iSender = new ( ELeave ) CSatBIPDataSender(

                        *aObserver, iSocket, iUseTcpProtocol,

                        iConnInfo.iBufferSize );

                }

            if ( iSender )

                {

                LOG( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL \

                iSender true" )

                // Send data

                iSender->SendData( ptr, iDestAddr );

                // Remove data from buffer.

                iSendStore = HBufC8::NewL( iConnInfo.iBufferSize );

                }

            }

        }

    // Place the number of bytes of empty space in the buffer to aFreeBufferSize

    aFreeBufferSize = ( iConnInfo.iBufferSize - iSendStore->Length() );

    LOG2( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::SendDataL exiting, \

          errCode: %d", errCode )

    return errCode;

    }

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

// Returns the received data in param aData

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

//

TInt CSatBIPGPRSDataChannel::ReceiveDataL( TDes8& aData,

    const TInt aBytesToRead, TInt& aAvailableBytes )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::ReceiveDataL calling" )

    TInt errCode( MSatBIPUtils::ESatBIPSuccess );

    // Number of bytes to return, may not be the same as requested

    TInt bytesToReturn( aBytesToRead );

    const TInt bytesAvail( iRcvBuffer.Length() );

    // Compare the number of bytes received and the number of bytes requested.

    if ( bytesToReturn > bytesAvail )

        {

        LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::ReceiveDataL \

        bytesToReturn > bytesAvail" )

        // There are no requested bytes availabe, we return all we have.

        errCode = MSatBIPUtils::ESatBIPReqBufSizeNotAvail;

        bytesToReturn = bytesAvail;

        }

    LOG2( NORMAL, "  ReceiveDataL: Data available for receive: %i", bytesAvail )

    // Put the data into param aData.

    aData = iRcvBuffer.Left( bytesToReturn );

    // Remove read data from receive store

    iRcvBuffer.Delete( 0, bytesToReturn );

    // Put the number of unread bytes into param aAvailableBytes.

    aAvailableBytes = iRcvBuffer.Length();

    LOG2( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::ReceiveDataL \

          aAvailableBytes: %d", aAvailableBytes )

    // Notify receiver if store is empty to get the next datagram in UDP sockets

    if ( ( 0 == aAvailableBytes ) && iReceiver )

        {

        iReceiver->ReceiveStoreEmptyNotificationL();

        }

    LOG2( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::ReceiveDataL exiting. \

          errCode: %d", errCode )

    return errCode;

    }

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

// Returns the identifier of this channel

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

//

TInt CSatBIPGPRSDataChannel::ChannelId() const

    {

    LOG2( SIMPLE,

    "SATENGINE: CSatBIPGPRSDataChannel::ChannelId calling - exiting,\

    ChannelId: %i", iChannelId.ChannelId() )

    return iChannelId.ChannelId();

    }

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

// Returns the identifier of this channel. This function is used only when

// generating ChannelStatus TLV object

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

//

TUint8 CSatBIPGPRSDataChannel::ChannelStatusChannelId() const

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPGPRSDataChannel::ChannelStatusChannelId calling" )

    TUint8 channelId( iChannelId.ShortChannelId() );

    LOG2( SIMPLE,

        "SATENGINE: CSatBIPGPRSDataChannel::ChannelStatusChannelId exiting \

        with channel id: %i", channelId )

    return channelId;

    }

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

// Returns the status of this data channel

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

//

TInt CSatBIPGPRSDataChannel::Status() const

    {

    LOG2( SIMPLE, 

    "SATENGINE: CSatBIPGPRSDataChannel::Status calling - exiting,\

    iChannelStatus: %i", iChannelStatus )

    return iChannelStatus;

    }

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

// Closes this data channel

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

//

void CSatBIPGPRSDataChannel::CloseChannel()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPGPRSDataChannel::CloseChannel calling" )

    if ( ESatBIPConnected == iConnStage ||

         ESatBIPCancelled == iConnStage )

        {

        LOG( NORMAL, "SATENGINE: CSatBIPGPRSDataChannel::CloseChannel \

            Channel is connected" )

        CancelAll();

        // Close socket