// Copyright (c) 2006-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:

//

// INCLUDE FILES

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CmmpacketcontexttsyTraces.h"

#endif

#include "Cmmpacketcontexttsy.h"

#include "Cmmpacketcontextlist.h"

#include "cmmpacketservicegsmwcdmaext.h"

#include "CMmPacketTsy.h"

#include "MmTsy_timeoutdefs.h"

#include "MmTsy_numberOfSlots.h"

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

CMmPacketContextTsy::CMmPacketContextTsy():

    iReqHandleType(EMultimodePacketContextReqHandleUnknown)

    {

    }

CMmPacketContextTsy* CMmPacketContextTsy::NewL(

        CMmPacketServiceTsy* const aMmPacketService,

        const TInfoName& aHostCID, 

        const TDes& aName,  

        const TUint8 aProxyId ) 

    {

OstTraceDefExt1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CMMPACKETCONTEXTTSY_NEWL_1,  "TSY: CMmPacketContextTsy::NewL. Context name:%S", aName );

    CMmPacketContextTsy* packetContext = new ( ELeave ) CMmPacketContextTsy();

    CleanupClosePushL( *packetContext );

    packetContext->iMmPacketService = aMmPacketService;

    packetContext->iContextName = aName;

    packetContext->iProxyId = aProxyId;

    packetContext->iHostCID = aHostCID;

    packetContext->ConstructL();

    CleanupStack::Pop();

    return packetContext;

    }

void CMmPacketContextTsy::ConstructL()

    {

    InitModulesL();

    InitInternalAttributes();    

    }

CMmPacketContextTsy::~CMmPacketContextTsy()

    {

OstTraceDefExt1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CMMPACKETCONTEXTTSY_DTOR_1,  "TSY: CMmPacketContextTsy::~CMmPacketContextTsy. Context name: %S", iContextName );

	if( iMmPacketService )

		{

		iMmPacketService->PacketContextList()->RemoveObject( this );

	    // Set Dynamic Caps

	    iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag(

	        RPacketService::KCapsActivate, EFalse );

	    if ( iIsDialUpContext )

	        {

	        iMmPacketService->ResetPointerToDialUpContext( iContextName );

	        }

		}

    delete iMmPacketContextGsmWcdmaExt;

    delete iTsyReqHandleStore;

    }

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

// CMmPacketContextTsy::InitModulesL

// Initialises extension modules for CMmPacketContextTsy

// (other items were commented in a header).

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

//

void CMmPacketContextTsy::InitModulesL()

    {

    iMmPacketContextGsmWcdmaExt = 

        CMmPacketContextGsmWcdmaExt::NewL( this, iMmPacketService );

#ifdef REQHANDLE_TIMER   

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(  this,

        iMmPacketService->PhoneTsy(), EMaxNumOfPacketContextRequests,

        iPacketContextReqHandles );

#else

        // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMaxNumOfPacketContextRequests, iPacketContextReqHandles );

#endif // REQHANDLE_TIMER

    }

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

// CMmPacketContextTsy::InitInternalAttributes

// Initialises miscellaneous internal attributes.

// (other items were commented in a header).

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

//

void CMmPacketContextTsy::InitInternalAttributes()

    {

    iQoSProfile = NULL;

    iQoSProfileName.Zero();

    iLastErrorCause = KErrNone;

    iContextStatus = RPacketContext::EStatusUnknown;

    iContextStatusBeforeSuspending = RPacketContext::EStatusUnknown;

    iConnectionSpeed = 0;

    iNotifyConnectionSpeed = 0;

    iIsDialUpContext = EFalse;

    if ( iContextName.Compare( KStringExternal )== 0 

         || iContextName.Compare( KStringExternal2 )== 0 )

        {

        iIsDialUpContext = ETrue;

        }

    }

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

// CMmPacketContextTsy::Init

// Initialisation method that is called from ETel Server.

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

//

void CMmPacketContextTsy::Init()

    {

    }

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

// CMmPacketContextTsy::ExtFunc

// TRAP's all CMmPacketContextTsy related MM Packet API requests in case that

// they fail. This method functions only as a centralized TRAP for the

// DoExtFuncL method that does the actual mapping of IPC number to TSY method

// call.

// (other items were commented in a header).

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

//

TInt CMmPacketContextTsy::ExtFunc( 

        const TTsyReqHandle aTsyReqHandle, 

        const TInt aIpc, 

        const TDataPackage& aPackage )  

    {

    TInt ret( KErrNone );

    TInt trapError( KErrNone );

#ifdef ADD_REMOVE_PACKETFILTER_DEFECT_FIXED  // search for this up from bottom of file

    // Ensure the ReqHandleType is unset.

    // This will detect cases where this method indirectly calls itself

    // (e.g. servicing a client call that causes a self-reposting notification to complete and thus repost).

    // Such cases are not supported because iReqHandleType is in the context of this class instance,

    // not this request, and we don't want the values set by the inner request and the outer request

    // interfering with each other.

    __ASSERT_DEBUG(iReqHandleType==EMultimodePacketContextReqHandleUnknown, User::Invariant());

#else

    // Reset last tsy request type

    iReqHandleType = EMultimodePacketContextReqHandleUnknown;

#endif

    // Trap the call of DoExtFuncL

    TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ) );

    if ( KErrNone != trapError )

        {

		// Reset the request handle to indicate the request is no longer ongoing

        iTsyReqHandleStore->FindAndResetTsyReqHandle( aTsyReqHandle );

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( KErrNone != ret )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

    else if ( EMultimodePacketContextReqHandleUnknown != iReqHandleType )

        {

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif // REQHANDLE_TIMER

        }

#ifdef ADD_REMOVE_PACKETFILTER_DEFECT_FIXED  // search for this up from bottom of file

     // We've finished with this value now. Clear it so it doesn't leak

     //  up to any other instances of this method down the call stack

     iReqHandleType = EMultimodePacketContextReqHandleUnknown;

#endif

    return KErrNone;

    }

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

// CMmPacketContextTsy::DoExtFuncL

// Packet Data specific functionality of CMmPacketContextTsy::ExtFunc

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

//

TInt CMmPacketContextTsy::DoExtFuncL( 

        const TTsyReqHandle aTsyReqHandle,      

        const TInt aIpc,      

        const TDataPackage& aPackage )   

    {

    TInt ret( KErrNotSupported );

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    switch ( aIpc )

        {

        case EPacketContextNotifyStatusChange:

            ret = NotifyStatusChange( 

                REINTERPRET_CAST( RPacketContext::TContextStatus*, dataPtr ) );

            break;

        case EPacketContextNotifyConfigChanged:

            ret = NotifyConfigChanged( 

                REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

            break;

        case EPacketContextNotifyConnectionSpeedChange:

            ret = NotifyConnectionSpeedChange( 

                REINTERPRET_CAST( TUint*, dataPtr ) );

            break;

        case EPacketContextInitialiseContext:

            {

            TDes8* paramData = aPackage.Des1n();

            if(paramData != NULL)

            	{

            	if(sizeof(RPacketContext::TDataChannelV2) > paramData->MaxLength())

            		{

            		ret = KErrArgument;

            		}

            	else

            		{

            		ret = InitialiseContextL( reinterpret_cast< RPacketContext::TDataChannelV2*>( dataPtr ));

            		}

            	}

            else

            	{

            	ret = KErrArgument;

            	}

            break;

            }

        case EPacketContextSetConfig:

            ret = SetConfigL( 

                REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

            break;

        case EPacketContextActivate:

            ret = ActivateL();

            break;

        case EPacketContextDeactivate:

            ret = DeactivateL();

            break;

        case EPacketContextDelete:

            ret = DeleteL();

            break;

        case EPacketContextGetStatus:

            ret = GetStatus( aTsyReqHandle, 

                REINTERPRET_CAST( RPacketContext::TContextStatus*, dataPtr ) );

            break;

        case EPacketContextGetConfig:

            ret = GetConfig( aTsyReqHandle, 

                REINTERPRET_CAST( TPacketDataConfigBase*, dataPtr ) );

            break;

        case EPacketContextGetProfileName:

            ret = GetProfileName( aTsyReqHandle, 

                REINTERPRET_CAST( TInfoName*, dataPtr ) );

            break;

        case EPacketContextGetConnectionSpeed:

            ret = GetConnectionSpeed( aTsyReqHandle, 

                REINTERPRET_CAST( TUint*, dataPtr ) );

            break;

        case EPacketContextGetLastErrorCause:

            ret = GetLastErrorCause( aTsyReqHandle, 

                REINTERPRET_CAST( TInt*, dataPtr ) );

            break;

        case EPacketContextGetDataVolumeTransferred:

            ret = GetDataVolumeTransferredL( aTsyReqHandle,

                REINTERPRET_CAST( RPacketContext::TDataVolume*, dataPtr ) );

            break;

        case EPacketContextEnumeratePacketFilters:

            ret = EnumeratePacketFilters( aTsyReqHandle,

                REINTERPRET_CAST( TInt*, dataPtr ) );

            break;

        case EPacketContextGetPacketFilterInfo:

            {

            TDes8* paramData = aPackage.Des2n();

            if (paramData)

            	{

            	TInt paramLength = paramData->MaxLength();

            	RPacketContext::TPacketFilterV2 temp;

            	RPacketContext::TPacketFilterV2Pckg tempPckg(temp);

            	TInt expectedLength = tempPckg.MaxLength();

				if (paramLength == expectedLength)

					{

		            ret = GetPacketFilterInfo( aTsyReqHandle, REINTERPRET_CAST( TInt*, dataPtr ), REINTERPRET_CAST( TPacketBase*, dataPtr2 ) );

					}

				else

					{

					ret = KErrArgument;

					}

            	}

            else

            	{

            	ret = KErrArgument;

            	}

            }

            break;

        case EPacketContextAddPacketFilter:

            ret = AddPacketFilterL( aTsyReqHandle, aPackage.Des1n() );

            break;

        case EPacketContextRemovePacketFilter:

#ifdef USING_CTSY_DISPATCHER            

        	ret = RemovePacketFilter( REINTERPRET_CAST( TInt*, dataPtr ) );

#else

        	ret = RemovePacketFilter( aTsyReqHandle,

                REINTERPRET_CAST( TInt*, dataPtr ) );     

#endif        	

        	break;

        case EPacketContextModifyActiveContext:

            ret = ModifyActiveContextL();

            break;

        case EPacketContextGetDNSInfo:

            ret = GetDnsInfo( aTsyReqHandle, aPackage.Des1n() );

            break;

        case EPacketAddMediaAuthorization:

	        ret = AddMediaAuthorizationL( aTsyReqHandle, aPackage.Des1n() );

	        break;

	    case EPacketRemoveMediaAuthorization:

	        ret = RemoveMediaAuthorization( aTsyReqHandle, 

	        		REINTERPRET_CAST( RPacketContext::TAuthorizationToken*,

                    dataPtr ) );

	        break;	        

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

        case EPacketContextGetConnectionInfo:

            ret = GetConnectionInfo( aTsyReqHandle, 

                reinterpret_cast<TConnectionInfoBase*>( dataPtr ) );            

            break;

        case EPacketContextNotifyConnectionInfoChange:

            ret = NotifyConnectionInfoChange(

                reinterpret_cast<TConnectionInfoBase*>( dataPtr ) ); 

            break;      

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

        // These requests currently not supported

        //case EPacketContextLoanCommPort:

        //case EPacketContextRecoverCommPort:

        //case EPacketContextNotifyDataTransferred:

        default:

            break;

        }

    return ret;

    }

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

// CMmPacketContextTsy::ReqModeL

// Returns request mode for given IPC.

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

//

CTelObject::TReqMode CMmPacketContextTsy::ReqModeL( 

        const TInt aIpc ) 

    {

    CTelObject::TReqMode reqMode( 0 );

    TBool doLeave( EFalse );

    switch ( aIpc )

        {

        // All disabled

        // TSYs wishing to implement their own buffering algorithm will place 

        // all requests in this category.  

        // Get methods that do not use DOS and return immediately. 

        // Flow control not required.

        case EPacketContextGetConnectionSpeed:

        case EPacketContextGetLastErrorCause:

        case EPacketContextGetProfileName:

        case EPacketContextEnumeratePacketFilters:

        case EPacketContextGetPacketFilterInfo:

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

        case EPacketContextGetConnectionInfo:                      

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

        // Other methods that do not use DOS and return immediately. 

        // Flow control not required.

        // Methods that can propably take a long time and cannot therefore be

        // flow controlled. Solution: All these methods must check req handle

        // table before handling the request. In case that the request table 

        // indicates that same method has been called and has not been 

        // completed, the method should return KErrServerBusy.

            if ( iIsDialUpContext )

                {

                doLeave = ETrue;

                break;

                }

        case EPacketContextGetStatus:

        case EPacketContextGetConfig:

            break;

        // KReqModeFlowControlObeyed

        // Commands that change the state of the phone, e.g. clearing the AoC 

        // counter, are commands that the TSY should only deal with one at 

        // a time.

        case EPacketContextInitialiseContext:

        case EPacketContextActivate:

        case EPacketContextDelete:

        case EPacketContextSetConfig:

        case EPacketContextAddPacketFilter:

        case EPacketContextRemovePacketFilter:

        case EPacketContextModifyActiveContext:

        case EPacketContextGetDNSInfo:

        case EPacketAddMediaAuthorization:

        case EPacketRemoveMediaAuthorization:

            if ( iIsDialUpContext )

                {

                doLeave = ETrue;

                break;

                }

        case EPacketContextDeactivate:

        case EPacketContextGetDataVolumeTransferred:

            {

            reqMode = KReqModeFlowControlObeyed;

            break;

            }

        // KReqModeMultipleCompletionEnabled | ReqModePostImmediately

        // Requests that notify a client about a change of state.

        // Since these requests do not require the issuing of any modem 

        // commands, they do not have to obey flow control.

        // The TSY never gets more than one of these outstanding.

        case EPacketContextNotifyConfigChanged:

        case EPacketContextNotifyConnectionSpeedChange:

            if ( iIsDialUpContext )

                {

                doLeave = ETrue;

                break;

                }

        case EPacketContextNotifyStatusChange:

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

        case EPacketContextNotifyConnectionInfoChange:           

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

            reqMode = KReqModeMultipleCompletionEnabled |

                KReqModeRePostImmediately;

            break;

        // Cancel Requests

        // It's not necessary to include the Cancel methods in ReqModeL at all.

        // The ETel server never calls ReqModeL with a Cancel IPC.

        // Other variations of return values are unusable.

        // Following requests are not supported

        //case EPacketContextNotifyDataTransferred:

        //case EPacketContextLoanCommPort:

        //case EPacketContextRecoverCommPort:

        // Default

        default:

            doLeave = ETrue;

            break;

        }

    if ( doLeave )

        {

        User::Leave( KErrNotSupported );

        }

    return reqMode;

    }

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

// CMmPacketContextTsy::NumberOfSlotsL

// Returns number of slots to be used for given IPC.

// (other items were commented in a header).

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

//

TInt CMmPacketContextTsy::NumberOfSlotsL(    

        const TInt aIpc )                            

    {

    TInt numberOfSlots( 0 );

    switch ( aIpc )

        {

        case EPacketContextNotifyStatusChange:

            numberOfSlots = KMmPacketContextNotifyStatusChangeSlots;

            break;

        case EPacketContextNotifyConfigChanged:

            numberOfSlots = KMmPacketContextNotifyConfigChangedSlots;

            break;

        case EPacketContextNotifyConnectionSpeedChange:

            numberOfSlots = KMmPacketContextNotifyConnectionSpeedChangeSlots;

            break;