// 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:

// ETel Multimode Packet Data API

// GPRS Release 97/98, CDMAOne, CDMA2000, Release 99 and Release 4.

// 

// Copyright (c) Symbian Software Ltd. 2002-2009.  All rights reserved.

// 

//

#include <et_clsvr.h>

#include <etelext.h>

// Packet Data header files

#include "pcktptr.h"

#include <pcktcs.h>

#include "pcktlist.h"

#include "etelpckt.h"

// Used by ETel to instruct the TSY to create a name for the newly opened object

_LIT(KETelNewContextName, "::");

TPacketBase::TPacketBase()

	{}

EXPORT_C TInt TPacketBase::ExtensionId() const

/**

	Returns the value of iExtensionId for the associated class.

	e.g. iExtensionId=KETelExtPcktV2 for all the V2 classes.

	@return The protected data member iExtensionId, which specifies the API version number.

*/

	{

	return iExtensionId;

	}

/***********************************************************************************/

//

// RPacketContext

//

/***********************************************************************************/

EXPORT_C RPacketContext::RPacketContext()

	:iEtelPacketContextPtrHolder(NULL)

/** 

	Standard constructor. 

*/

	{

	}

EXPORT_C void RPacketContext::ConstructL()

/**

	This function creates an instance of CPacketContextPtrHolder and assigns it to the

	iEtelPacketContextPtrHolder pointer.

*/

	{

	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));

	iEtelPacketContextPtrHolder = CPacketContextPtrHolder::NewL(CEtelPacketPtrHolder::EMaxNumPacketContextPtrSlots, CEtelPacketPtrHolder::EMaxNumPacketContextPtrCSlots);

	}

EXPORT_C void RPacketContext::Destruct()

/**

	This function deletes and NULLs the iEtelPacketContextPtrHolder pointer.

*/

	{

	delete iEtelPacketContextPtrHolder;

	iEtelPacketContextPtrHolder = NULL;

	}

EXPORT_C TInt RPacketContext::OpenNewContext(RPacketService& aPacketNetwork,TDes& aContextName)

// This function may be called by the client application.

/**

	Creates a primary PDP context (i.e. RPacketContext) on an existing RPacketService

	connection.

	There is a global mutex around this method and the RPacketService::OpenNewSecondaryContext()

	method. There is a potential problem with an Open function that makes an initial "set-up"

	function call - another client could also call OpenNewSecondaryContext() or

	OpenNewContext() at the same time, and the wrong client's OpenNewObjectL() will reach the

	TSY first. This would mean clients would receive handles to the wrong context!

	To avoid this, the API code for both OpenNewContext() and OpenNewSecondaryContext() must

	have a shared global mutex around it, so only one client can call either of these two

	functions at any one time.

	The TSY will return KErrUmtsMaxNumOfContextExceededByPhone if the number of PDP contexts

	supported by the phone is exceeded. The TSY will return KErrUmtsMaxNumOfContextExceededByNetwork

	if the number of PDP contexts supported by the network is exceeded.

	An opened RPacketContext must be closed explicitly by calling Close() to

	prevent a resource (memory) leak.

	@param aPacketNetwork An RPacketContext may only be opened from an existing RPacketService

	subsession. A client application must therefore pass a reference to their previously

	instantiated RPacketService object.

	@param aContextName When the new context is created, the TSY will assign it a unique name

	and pass this name back to the client using this parameter. The client can use this name to

	uniquely identify the particular context.

	@return KErrNone if successful, a system-wide error code if not.

@capability None

*/

	{

	RSessionBase* session=&aPacketNetwork.SessionHandle();

	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle)); // client has no existing session with ETel

	TRAPD(ret,ConstructL());

	if (ret)

		return ret;

	TInt subSessionHandle=aPacketNetwork.SubSessionHandle();

	__ASSERT_ALWAYS(subSessionHandle!=0,PanicClient(EEtelPanicNullHandle)); // client has no existing sub-session!

	TPtrC name(KETelNewContextName); // necessary so that server knows to ask TSY for new name

	SetSessionHandle(*session);

	aPacketNetwork.iMutex.Wait();					// wait for access to the mutex	

	TIpcArgs args(&name,&aContextName,subSessionHandle);

	ret= CreateSubSession(*session,EEtelOpenFromSubSession,args);

	aPacketNetwork.iMutex.Signal();					// Unblock the mutex

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C TInt RPacketContext::OpenExistingContext(RPacketService& aPacketNetwork, const TDesC& aContextName)

// This function may be called by the client application.

/**

	Opens a handle on an existing context (RPacketContext) object, either primary or secondary,

	identified by a name.

	KErrNotFound is returned if the object does not exist.

	An opened RPacketContext must be closed explicitly by calling Close() to

	prevent a resource (memory) leak.

	@param aPacketNetwork This identifies the packet network (RPacketService) the particular

	context to be opened belongs. All existing contexts must have an RPacketService parent.

	@param aContextName This uniquely identifies to ETel which existing RPacketContext object

	the client wants to open. This name was previously assigned by the TSY when the specified

	RPacketContext was created, using OpenNewContext().

	@return KErrNone if successful, KErrNotFound if the object does not exist.

@capability None

*/

	{

	RSessionBase* session=&aPacketNetwork.SessionHandle();

	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle));

	TRAPD(ret,ConstructL());

	if (ret)

		{

		Destruct();

		return ret;

		}

	TInt subSessionHandle=aPacketNetwork.SubSessionHandle();

	__ASSERT_ALWAYS(subSessionHandle!=0,PanicClient(EEtelPanicNullHandle));

	__ASSERT_ALWAYS(aContextName.Length()!=0,PanicClient(KErrBadName));

	SetSessionHandle(*session);

	TIpcArgs args(&aContextName,TIpcArgs::ENothing,subSessionHandle);

	ret = CreateSubSession(*session,EEtelOpenByNameFromSubSession,args);

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C void RPacketContext::Close()

// This function may be called by the client application.

/** Closes the client's current sub-session with ETel. Any outstanding requests

	the client may have with ETel (notifications, for example) will be automatically

	destroyed by ETel.

	An opened RPacketContext must be closed explicitly by calling Close() to

	prevent a resource (memory) leak. 

@capability None

*/

	{

	CloseSubSession(EEtelClose);

	Destruct();

	}

EXPORT_C void RPacketContext::SetConfig(TRequestStatus& aStatus, const TDesC8& aConfig) const

// This function may be called by the client application.

/** 

	Passes to the TSY all the parameters necessary to configure the particular 

	context. The parameters are passed via a packaged TContextConfigGPRS/

	TContextConfigCDMA/TContextConfigR99_R4/RPacketMbmsContext::TContextConfigMbmsV1

	object depending on the current network mode.

	This is an asynchronous function.

	In the case of this function call, the value for each TContextConfigXXX parameter will be 

	input by the client and probably obtained from CommDB. To determine how to correctly unpack 

	the descriptor inside the TSY, the TSY must first cast the descriptor to a 

	TPacketDataConfigBase pointer and check whether ExtensionId() returns a KConfigGPRS, 

	KConfigCDMA,KConfigRel99Rel4 or KConfigMBMS. The TSY will then cast the descriptor to the correct 

	TPacketDataConfigBase-derived class.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextSetConfig) to cancel 

	a previously placed asynchronous SetConfig() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

	@param aConfig A TContextConfigXXX object packaged as a TPckg<TContextConfigXXX>. 

@capability WriteDeviceData

*/

	{

	Set(EPacketContextSetConfig, aStatus, aConfig);

	}

EXPORT_C void RPacketContext::GetConfig(TRequestStatus& aStatus, TDes8& aConfig) const

// This function may be called by the client application.

/** 

	Gets the configuration of the current context. 

	This is an asynchronous function.

	In the case of this function call, the value for each TContextConfigXXX parameter will 

	be input by the TSY.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextGetConfig) to cancel 

	a previously placed asynchronous GetConfig() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

	@param aConfig On completion, a TContextConfigXXX context configuration object packaged 

	as a TPckg<TContextConfigXXX>.  

@capability ReadDeviceData

*/

	{

	Get(EPacketContextGetConfig, aStatus, aConfig);

	}

EXPORT_C void RPacketContext::NotifyConfigChanged(TRequestStatus& aStatus, TDes8& aConfig) const

// This function may be called by the client application.

// At the RPacketContext level, there are only minor differences between GPRS and UMTS contexts.

/**

	Allows a client to be notified whenever a change in the current context is 

	detected and gets the updated configuration.

	This is an asynchronous function.

	In the case of this function call, the value for each parameter will be input by the TSY.

	It should be noted that once the notification completes, the client must then re-post the 

	notification if they wish to continue receiving the notification.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextNotifyConfigChanged) 

	to cancel a previously placed asynchronous NotifyConfigChanged() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

	@param aConfig On completion, a TContextConfigXXX context configuration object packaged 

	as a TPckg<TContextConfigXXX>.

@capability ReadDeviceData

*/

	{

	Get(EPacketContextNotifyConfigChanged, aStatus, aConfig);

	}

EXPORT_C void RPacketContext::Activate(TRequestStatus& aStatus) const

// This function may be called by the client application.

/**

	Activates a context that has been previously configured using SetConfig(). 

	Once this function completes, the context will remain in an 'Activating' state 

	until a layer 2 connection (e.g.: PPP or SLIP) has been successfully negotiated 

	between the phone and the packet network gateway. Once the link layer has 

	been negotiated, the context can be considered to be 'Activated'.

	This is an asynchronous function.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextActivate) to cancel 

	a previously placed asynchronous Activate() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

@capability NetworkServices

*/

	{

	Blank(EPacketContextActivate,aStatus);

	}

EXPORT_C void RPacketContext::Deactivate(TRequestStatus& aStatus) const

// This function may be called by the client application.

/**

	Deactivates a context previously configured on the phone.

	This is an asynchronous function.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextDeactivate) to cancel 

	a previously placed asynchronous Deactivate() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide

	error codes.

@capability NetworkServices

*/

	{

	Blank(EPacketContextDeactivate, aStatus);

	}

EXPORT_C void RPacketContext::Delete(TRequestStatus& aStatus) const

/** Deletes a context previously configured on the phone.

	This asynchronous function may be called by the client application.

	Although the context is deleted from the TSY (and/or ME), the client's 

	RPacketContext/RPacketMbmsContext subsession remains. 

	To remove this, a client must call Close(). 

	This is an asynchronous function.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextDelete) to cancel 

	a previously placed asynchronous Delete() request.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

@capability WriteDeviceData

*/

	{

	Blank(EPacketContextDelete, aStatus);

	}

EXPORT_C void RPacketContext::LoanCommPort(TRequestStatus& aStatus, RCall::TCommPort& aDataPort) const

/** 

	Provides a client with details of the comm port to be used for sending/receiving 

	user data in version 1 of the API. This comm port is used by Network Interfaces, NIFs, 

	(for example: PPP.NIF) to send and receive data. In a 2-box device this port would generally 

	be the same as that used by the TSY to set up and control the connection. 

	In a 1-box device this port would generally be different to the port used 

	by the TSY to set up and control the connection.

	This asynchronous function may be called by the client application.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextLoanCommPort) to 

	cancel a previously placed asynchronous LoanCommPort() request.

	@deprecated Superceded in v7.0S

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

	@param aDataPort A reference to a TCommPort class containing information on 

	the port, including its name and the associated CSY used to access it. 

@capability NetworkServices

*/

	{

	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotDataPort,aDataPort);

	Get(EPacketContextLoanCommPort,aStatus,ptr1);

	}

EXPORT_C void RPacketContext::RecoverCommPort(TRequestStatus& aStatus) const

/**

	Allows a client, who previously called LoanCommPort(), to inform ETel and hence 

	the TSY that it has finished with the comm port, in version 1 of the API.

	This asynchronous function may be called by the client application.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextRecoverCommPort) 

	to cancel a previously placed asynchronous RecoverCommPort() request.

	@deprecated Superceded in v7.0S.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide 

	error codes.

@capability NetworkServices

*/

	{

	Blank(EPacketContextRecoverCommPort, aStatus);

	}

EXPORT_C TInt RPacketContext::GetStatus(TContextStatus& aContextStatus) const

/**

	Allows a client to get the current status of the context.

	This synchronous function may be called by the client application.

	@param aContextStatus On return, the current status of the context.

	@return KErrNone if successful, a system-wide error code if not.

@capability None

*/

	{

	TPckg<TContextStatus> ptr1(aContextStatus);

	return Get(EPacketContextGetStatus, ptr1);

	}

EXPORT_C void RPacketContext::NotifyStatusChange(TRequestStatus& aStatus,TContextStatus& aContextStatus)

// This function may be called by the client application.

/**

	Allows a client to receive a notification whenever a change in the status of

	the context is detected and gets the new context status.

	This is an asynchronous function.

	Once the notification completes, the client must re-post the notification 

	if they wish to continue receiving further status change notifications.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextNotifyStatusChange) 

	to cancel a previously placed asynchronous NotifyStatusChange() request.

	@param aStatus KErrNone if successful, otherwise another of the system-wide 

	error codes.

	@param aContextStatus On completion, the new context status.

@capability None

*/

	{

	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotContextStatus,aContextStatus);

	Get(EPacketContextNotifyStatusChange,aStatus,ptr1);

	}	

EXPORT_C TInt RPacketContext::GetProfileName(TName& aQoSProfile) const

/**

	Allows a client to retrieve the name of the Quality of Service profile 

	(RPacketQoS) associated with the context.

	This is an synchronous function.

	@param aQoSProfile On return, a reference to the name of the existing QoS 

	profile. If no profile has been defined then this name will be NULL.

	@return KErrNone if successful, a system-wide error code if not.

@capability None

*/

	{

	TPckg<TName> ptr1(aQoSProfile);

	return Get(EPacketContextGetProfileName, ptr1); 

	}

EXPORT_C TInt RPacketContext::GetDataVolumeTransferred(TDataVolume& aVolume) const

/**

	Allows a client to get details on the current amount of data transmitted and 

	received over the airlink since the context was activated, in version 1 of the API.

	This synchronous method may be called by the client application.

	@deprecated Use asynchronous version from v7.0S.

	@param aVolume On return, a reference to TDataVolume with the current amount 

	of data transmitted and received.

	@return KErrNone if successful, a system-wide error code if not.

@capability ReadUserData

*/

	{

	TPckg<TDataVolume> ptr1(aVolume);

	return Get(EPacketContextGetDataVolumeTransferred, ptr1);

	}

EXPORT_C void RPacketContext::GetDataVolumeTransferred(TRequestStatus& aStatus, TDataVolume& aVolume) const

//This function may be called by the client.

/**

	Allows a client to get details on the current amount of data transmitted and received over the airlink 

	since the context was activated, for version 2 of this API onwards.

	This is an asynchronous function. Note that the synchronous variant of this method is deprecated.

	Introduced in v7.0S.

	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.

	@param aVolume On return, a reference to TDataVolume with the current amount of data transmitted and 

	received.

@capability ReadUserData

*/

	{

	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	TPtr8& ptr1 = iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetDataVolumeTransferred, aVolume);

	Get(EPacketContextGetDataVolumeTransferred, aStatus, ptr1);

	}

EXPORT_C void RPacketContext::NotifyDataTransferred(TRequestStatus& aStatus, TDataVolume& aVolume, TUint aRcvdGranularity,TUint aSentGranularity) const

// This function may be called by the client application.

/**

	Allows a client to be notified of a change in the volume of data transmitted 

	and received over the airlink since the context was activated and gets the 

	new volume.

	The notification will only complete when the change in volume increases by 

	a client-specified amount (granularity). The default granularity for each 

	direction (rx/tx) is 4KB. 

	This is an asynchronous function.

	Once the notification completes, the client must then re-post the notification 

	if they wish to continue receiving further notifications.

	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextNotifyDataTransferred) 

	to cancel a previously placed asynchronous NotifyDataTransferred() request.

	@param aStatus KErrNone if successful, otherwise another of the system-wide 

	error codes.