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

// This file implements the CGprs class. Used to implement the RPacketService API.

// This file also implements the CGprsContextEntry class used to store a pointer to a CGprsContext object.

// 

//

/**

 @file

*/

#include "Gprscontext.h"

#include "mSLOGGER.H"

#include "NOTIFY.H"

#include "ATGprsAttach.H"

#include "ATGprsDetach.H"

#include "AtGprsClass.h"

#include "atgprsntwkregstatus.h"					// for CATGprsNtwkRegStatus

#include "atgprsntwkregstatuschange.h"		// for CATGprsNtwkRegStatusChange

#include "ATIO.H"

#include "ATHANGUP.H"

CGprs* CGprs::NewL(CATIO* aIo, CATInit* aInit, CPhoneGlobals* aPhoneGlobals)

/**

 * Standard 2 phase constructor.

 *

 * @param aIo pointer to communication object.

 * @param aInit pointer to AT phone init object.

 * @param aPhoneGlobals pointer to phone global wide states.

 */

    {

    CGprs* gprs=new(ELeave) CGprs(aIo, aInit, aPhoneGlobals);

    CleanupStack::PushL(gprs);

    gprs->ConstructL();

    CleanupStack::Pop();

    return gprs;

    }

CGprs::CGprs(CATIO* aIo, CATInit*   aInit, CPhoneGlobals* aPhoneGlobals) 

        : CSubSessionExtBase(), iIo(aIo), iInit(aInit), iPhoneGlobals(aPhoneGlobals)

/**

 * Constructor

 *

 * @param aIo pointer to communication object.

 * @param aInit pointer to AT phone init object.

 * @param aPhoneGlobals pointer to phone global wide states.

 */

    {

    LOGTEXT(_L8("CGprs: Entered constructor"));

    }    

void CGprs::ConstructL()

/**

 * Construct all objects that can leave.

 */

    {

    LOGTEXT(_L8("CGprs: ConstructL"));

    iContexts.SetOffset(_FOFF(CGprsContextEntry,iLink));

    iATGPRSAttach       = CATGprsAttach::NewL(iIo, this, iInit, iPhoneGlobals); 

    iATGprsDetach       = CATGprsDetach::NewL(iIo, this, iInit, iPhoneGlobals); 

    iATGprsClass        = CATGprsClass::NewL(iIo, this, iInit, iPhoneGlobals);

    iATGprsNtwkRegStatusChange= CATGprsNtwkRegStatusChange::NewL(iIo,this,iPhoneGlobals);

    iATGprsNtwkRegStatus= CATGprsNtwkRegStatus::NewL(iIo, this, iInit, iPhoneGlobals,iATGprsNtwkRegStatusChange);

   	iMutex.CreateGlobal(KNullDesC, EOwnerProcess);

    }

RHandleBase* CGprs::GlobalKernelObjectHandle()

/**

* Implements CSubSessionExtBase virtual method, which provides

* handle of the mutex object to etel server that passes it up to clients.

* @return pointer to synchronisation mutex object

*/

	{

		return &iMutex;

	}

CGprs::~CGprs()

/**

 * Destructor

 */

    {

    LOGTEXT(_L8("CGprs: Entered destructor"));

	iMutex.Close();

    iPhoneGlobals->iNotificationStore->RemoveClientFromLastEvents(this);

    CGprsContextEntry* contextEntry;

    TDblQueIter<CGprsContextEntry> iter(iContexts);

    while (contextEntry=iter++, contextEntry)

        {

        contextEntry->Deque();

        contextEntry->iContext->Close();

        delete contextEntry;

        __ASSERT_ALWAYS(iContexts.IsEmpty(),Panic(EPacketContextsRemaining));

        }

		delete iATGprsNtwkRegStatusChange;

		delete iATGprsNtwkRegStatus;

    delete iATGprsClass;

    delete iATGprsDetach; 

		delete iATGPRSAttach;

    }

void CGprs::Init()

/**

 * This function does nothing.

 */

    {

    LOGTEXT(_L8("CGprs: init()"));

    }

CTelObject* CGprs::OpenNewObjectByNameL(const TDesC& /*aName*/)

/**

 * This functionality does not have to be supported as it is

 * not requitred by the Etel Packet API (etelpckt).

 */

    {  

    LOGTEXT(_L8("CGprs::OpenNewObjectByNameL Leaving with KErrNotFound as this is not supported"));

    User::Leave(KErrNotFound);		// Have to leave otherwise etel will think we have returned a

		                              // valid CTelObject and will cause an access violation.

		return NULL;

    }

CTelObject* CGprs::OpenNewObjectL(TDes& aNewName)

/**

 * This function returns a pointer to a new context object.

 *

 * @param  aNewName name of the new context.

 */

    {

    TInt cid = 0;

    GenerateNewContextNameAndCid(aNewName, cid);

    if(cid > MaxNumberOfContexts())

        User::Leave(KErrOverflow);

#if defined __LOGDEB__ 

    TBuf8<40> tmpLog;

    tmpLog.Copy(aNewName);

    LOGTEXT2(_L8("CGprs::OpenNewObjectL(), %S"), &tmpLog);

#endif

    RPacketContext::TContextConfigGPRS contextConfigV01;

    ContextConfigGPRS(&contextConfigV01);

    CGprsContext* context = CGprsContext::NewL(this, iIo, iInit, iPhoneGlobals, aNewName,  cid, &contextConfigV01);

	CleanupStack::PushL(context);

    AppendNewContextL(context);

	CleanupStack::Pop(context);

    iPhoneGlobals->iNotificationStore->CheckNotification(this, EPacketContextAddedChanged);

    return context;

    } 

CTelObject::TReqMode CGprs::ReqModeL(const TInt aIpc)

/**

 * This function is called from the framework and checks the flow control for a IPC call.

 * @param aIpc IPC call from client.

 */

	{

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

		case EPacketAttach:

		case EPacketDetach:

		case EPacketSetMSClass:

			ret = KReqModeFlowControlObeyed;

			break;

		case EPacketGetNtwkRegStatus:

			if (!iPhoneGlobals->iPhoneStatus.iDataPortLoaned)

				{

				ret = KReqModeFlowControlObeyed;

				}

			break;

		case EPacketGetMSClass:

		case EPacketGetDynamicCaps:

		case EPacketGetDefaultContextParams:

		case EPacketGetStatus:

		case EPacketEnumerateContexts:

		case EPacketGetContextInfo:

		case EPacketGetAttachMode:

		case EPacketGetStaticCaps: 

		case EPacketSetDefaultContextParams:

		case EPacketRejectActivationRequest:

		case EPacketSetAttachMode:

			break;

		case EPacketNotifyContextAdded:

		case EPacketNotifyStatusChange:

		case EPacketNotifyChangeOfNtwkRegStatus:	

			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

			break; 

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	// Check if the data port is currently loaned. If it is and the requested IPC

	// is flow controlled then block Etel calling the IPC by leaving with KErrInUse

	if((ret&KReqModeFlowControlObeyed) && iPhoneGlobals->iPhoneStatus.iDataPortLoaned)

		{

		LOGTEXT2(_L8("ReqModeL Leaving with KErrInUse as data port is loaned (aIpc=%d)"),aIpc);

		User::Leave(KErrInUse);

		}

    return ret;

    }

TInt CGprs::RegisterNotification(const TInt aIpc)

/**

 * This function is called from the framework.

 * @param  aIpc IPC call from client.

 */

    {

	LOGTEXT2(_L8("CGprs::RegisterNotification called with aIpc=%d"),aIpc);

    switch (aIpc)

        {

        case EPacketNotifyContextAdded:

        case EPacketNotifyStatusChange:

        case EPacketNotifyContextActivationRequested:

        case EPacketNotifyChangeOfNtwkRegStatus:

        case EPacketNotifyMSClassChange:

        case EPacketNotifyDynamicCapsChange:

            return KErrNone;

        default:

            // Unknown or invalid IPC

            LOGTEXT2(_L8("CGprs::RegisterNotification Error Unknown IPC, aIpc=%d"),aIpc);

            return KErrNotSupported;

        }

    }

TInt CGprs::DeregisterNotification(const TInt aIpc)

/**

 * This function is called when there is no client listening to a notification anymore.

 * @param aIpc IPC call from client.

 */

    {

	LOGTEXT2(_L8("CGprs::DeregisterNotification called with aIpc=%d"),aIpc);

    switch (aIpc)

        {

        case EPacketNotifyContextAdded:

        case EPacketNotifyStatusChange:

        case EPacketNotifyContextActivationRequested:

        case EPacketNotifyChangeOfNtwkRegStatus:

        case EPacketNotifyMSClassChange:

        case EPacketNotifyDynamicCapsChange:

            return KErrNone;

        default:

            // Unknown or invalid IPC

            LOGTEXT2(_L8("CGprs::DeregisterNotification Error Unknown IPC, aIpc=%d"),aIpc);

            return KErrNotSupported;

        }

    }

TInt CGprs::NumberOfSlotsL(const TInt aIpc)

/**

 * This function is called from the framework and checks the number of slots for a notification.

 * @param aIpc IPC call from client.

 */

    {

    TInt numberOfSlots=0;

    switch (aIpc)

        {

        case EPacketNotifyStatusChange:

        case EPacketNotifyDynamicCapsChange:

            LOGTEXT(_L8("CGprs: Registered with 10 slot"));

            numberOfSlots=10;

            break;

        case EPacketNotifyContextAdded:

        case EPacketNotifyContextActivationRequested:

        case EPacketNotifyChangeOfNtwkRegStatus:

        case EPacketNotifyMSClassChange:

            LOGTEXT(_L8("CGprs: Registered with 2 slot"));

            numberOfSlots=2;

            break;

        default:

            // Unknown or invalid IPC

            LOGTEXT2(_L8("CGprs: Number of Slots error, unknown IPC:%d"),aIpc);

            User::Leave(KErrNotSupported);

            break;

        }  

    return numberOfSlots;

    }

TInt CGprs::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,const TDataPackage& aPackage)

/**

 * This function is called from the framework.

 * @param aTsyReqHandle handle to client.

 * @param aIpc IPC call from client.

 * @param aPackage agruments with the IPC call.

 */

    {

    TAny* dataPtr=aPackage.Ptr1();

    TAny* dataPtr2=aPackage.Ptr2();

    switch (aIpc)

        {

        case EPacketNotifyContextAdded:

            return NotifyContextAdded(aTsyReqHandle, aPackage.Des1u());

        case EPacketGetStatus:

            return GetStatus(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

        case EPacketNotifyStatusChange:

            return NotifyStatusChange(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

        case EPacketNotifyContextActivationRequested:

            return NotifyContextActivationRequested(aTsyReqHandle,

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

        case EPacketEnumerateContexts:

            return EnumerateContexts(aTsyReqHandle,

            REINTERPRET_CAST(TInt*, dataPtr),

            REINTERPRET_CAST(TInt*, dataPtr2));

        case EPacketGetContextInfo:

            return GetContextInfo(aTsyReqHandle,

            *REINTERPRET_CAST(TInt*, dataPtr),

            REINTERPRET_CAST(RPacketService::TContextInfo*, dataPtr2));

        case EPacketGetNtwkRegStatus:

            return GetNtwkRegStatus(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

        case EPacketNotifyChangeOfNtwkRegStatus:

            return NotifyChangeOfNtwkRegStatus(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

        case EPacketGetMSClass:

            return GetMSClass(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr),

            REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr2));

        case EPacketSetMSClass:

            return SetMSClass(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

        case EPacketNotifyMSClassChange:

            return NotifyMSClassChange(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

        case EPacketGetStaticCaps:

            return GetStaticCaps(aTsyReqHandle, 

				REINTERPRET_CAST(TUint*, dataPtr),

				REINTERPRET_CAST(RPacketContext::TProtocolType*, dataPtr2));

        case EPacketGetDynamicCaps:

            return GetDynamicCaps(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

        case EPacketNotifyDynamicCapsChange:

            return NotifyDynamicCapsChange(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

        case EPacketSetAttachMode:

            return SetAttachMode(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

        case EPacketGetAttachMode:

            return GetAttachMode(aTsyReqHandle,

            REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

        case EPacketAttach:

            return Attach(aTsyReqHandle);

        case EPacketDetach:

            return Detach(aTsyReqHandle);

        case EPacketRejectActivationRequest:

            return RejectActivationRequest(aTsyReqHandle);

        case EPacketSetDefaultContextParams:

            return SetDefaultContextParams(aTsyReqHandle, aPackage.Des1n());

        case EPacketGetDefaultContextParams:

            return GetDefaultContextParams(aTsyReqHandle, aPackage.Des1n());

        default:

            return KErrNotSupported;

        }

    }

TInt CGprs::CancelService(const TInt aIpc, const TTsyReqHandle aTsyReqHandle)

/**

 * This function is called from the framework and cancels a outstanding request.

 * @param aIpc The IPC to cancel.

 * @param aTsyReqHandle the client handle to cancel.

 */

    {

    LOGTEXT(_L8("CGprs: - CancelService called"));

    switch (aIpc)

        {

        case EPacketNotifyContextAdded:

            return NotifyContextAddedCancel(aTsyReqHandle);

        case EPacketAttach:

            return AttachCancel(aTsyReqHandle);

        case EPacketDetach:

            return DetachCancel(aTsyReqHandle);

        case EPacketNotifyStatusChange:

            return NotifyStatusChangeCancel(aTsyReqHandle);

        case EPacketNotifyContextActivationRequested:

            return NotifyContextActivationRequestedCancel(aTsyReqHandle);

        case EPacketRejectActivationRequest:

            return RejectActivationRequestCancel(aTsyReqHandle);

        case EPacketGetContextInfo:

            return GetContextInfoCancel(aTsyReqHandle);

        case EPacketNotifyChangeOfNtwkRegStatus:

            return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle);

        case EPacketGetMSClass:

            return GetMSClassCancel(aTsyReqHandle);

        case EPacketSetMSClass:

            return SetMSClassCancel(aTsyReqHandle);

        case EPacketNotifyMSClassChange:

            return NotifyMSClassChangeCancel(aTsyReqHandle);

        case EPacketNotifyDynamicCapsChange:

            return NotifyDynamicCapsChangeCancel(aTsyReqHandle);

				case EPacketGetNtwkRegStatus:

            return GetNtwkRegStatusCancel(aTsyReqHandle);

        default:

            return KErrGeneral; // Should never get to this point, as Etel should try to cancel IPC we do not support

        } 

    }

void CGprs::AppendNewContextL(CGprsContext* aNewContext)

/**

 * This function adds a context to the list.

 *

 * @param aNewContext Adds a context to the linked list of contexts.

 */

    {

    LOGTEXT(_L8("CGprs::AppendNewContextL called"));

    CGprsContextEntry* entry = new (ELeave) CGprsContextEntry(aNewContext);

    iContexts.AddLast(*entry);

    }

void CGprs::RemoveContext(CGprsContext* aContext)

/**

 * This function removes a context from the list.

 *

 * @param aContext Context to remove from linked list.

 */

    {

#ifdef _DEBUG

    TBuf8<KMaxName> tmpLog;

    tmpLog.Copy(*(aContext->ContextName()));		// Convert 16bit string to 8bit so we can log it

    LOGTEXT2(_L8("CGprs::RemoveContext called, %S"), &tmpLog);

#endif

    CGprsContextEntry* contextEntry;

    TDblQueIter<CGprsContextEntry> iter(iContexts);

    while (contextEntry=iter++, contextEntry)

        {

        if (contextEntry->iContext == aContext)

            {

            contextEntry->Deque();

            delete contextEntry;    // just deletes list entry, not the context itself

            break;

            }

        }

    }

TDes* CGprs::NameOfLastAddedContext()

/**

 * This function gets the name of the last added context.

 */

    {

    if (iContexts.IsEmpty())

        return NULL;

    CGprsContextEntry* contextEntry = iContexts.Last();

    __ASSERT_ALWAYS(contextEntry,Panic(EPacketContextDoesNotExist));

    return (contextEntry->iContext->ContextName());

    }

RPacketService::TStatus CGprs::Status()

/**

 * This function returns the GPRS status.

 */

    {

    return iPhoneGlobals->iGprsStatus;

    }

void CGprs::SetStatus(RPacketService::TStatus aStatus)

/**

 * This function sets the GPRS status.

 * @param aStatus Status to set.

 */

    {

    iPhoneGlobals->iGprsStatus = aStatus;

    }

RPacketService::TRegistrationStatus CGprs::RegistrationStatus()

/**

 * This function returns the GPRS network registration status.

 */

    {

    return iPhoneGlobals->iGprsRegistrationStatus;

    }

void CGprs::SetRegistrationStatus(RPacketService::TRegistrationStatus aStatus)

/**

 * This function sets the GPRS registration status.

 * @param aStatus Status to set.

 */

    {

    iPhoneGlobals->iGprsRegistrationStatus = aStatus;

    }

TInt CGprs::NumberOfContexts()

/**

 * This function returns the number of contexts.

 */

    {

    TInt count=0;

    TDblQueIter<CGprsContextEntry> iter(iContexts);

    while (iter++)

        {

        count++;

        }

    return count;

    }

void CGprs::GenerateNewContextNameAndCid(TDes& aName, TInt& aCid)

/**