FCL/sf/os/cellularsrv: comparison telephonyserver/etelpacketdata/cetel/etelpckt.cpp

equal deleted inserted replaced

--1:000000000000
+:3553901f7fa8
+// 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.
+	@param aVolume On return, a reference to the current amount of data transmitted
+	and received.
+	@param aRcvdGranularity The granularity for the volume of received data.
+	@param aSentGranularity The granularity for the volume of transmitted data.
+@capability ReadUserData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketContextPtrHolder->iNotifyDataTransferRequest.iRcvdGranularity=aRcvdGranularity;
+	iEtelPacketContextPtrHolder->iNotifyDataTransferRequest.iSentGranularity=aSentGranularity;
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotDataVolume,aVolume);
+	TPtr8& ptr2=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotGranularity,iEtelPacketContextPtrHolder->iNotifyDataTransferRequest);
+	Get(EPacketContextNotifyDataTransferred, aStatus, ptr1, ptr2);
+	}
+EXPORT_C void RPacketContext::GetConnectionSpeed(TRequestStatus& aStatus, TUint& aRate) const
+// This function may be called by the client application.
+/**
+	Gets the current connection speed.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextGetConnectionSpeed)
+	to cancel a previously placed asynchronous GetConnectionSpeed() request.
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide
+	error codes.
+	@param aRate On return, the current connection bandwidth in bits per second.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1 = iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetSpeed, aRate);
+	Get(EPacketContextGetConnectionSpeed, aStatus, ptr1);
+	}
+EXPORT_C void RPacketContext::NotifyConnectionSpeedChange(TRequestStatus& aStatus, TUint& aRate) const
+//This function may be called by the client.
+/**
+	Allows a client to be notified whenever the current connection speed changes
+	and gets the current connection speed.
+	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(EPacketContextNotifyConnectionSpeedChange)
+	to cancel a previously placed asynchronous NotifyConnectionSpeedChange() request.
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide
+	error codes.
+	@param aRate On return, the current connection bandwidth in bits per second.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotNotifySpeed, aRate);
+	Get(EPacketContextNotifyConnectionSpeedChange, aStatus, ptr1);
+	}
+EXPORT_C void RPacketContext::GetConnectionInfo(TRequestStatus& aStatus, TDes8& aInfo) const
+// This function may be called by the client.
+/**
+	Gets the current connection information.
+	This is an asynchronous function.
+	In the case of this function call, the members of class TConnectionInfoV1 or any later
+	derived versions supplied by the client will be returned, eg. TConnectionInfoVx.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketContextGetConnectionInfo)
+	to cancel a previously placed asynchronous GetConnectionInfo() request.
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide
+	error codes.
+	@param aInfo TConnectionInfoV1 or any later derived versions supplied by the client packaged
+	as a TPckg<TConnectionInfoVx>.
+	N.B. only supported if telephony was built with SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW macro
+@capability None
+*/
+	{
+	Get(EPacketContextGetConnectionInfo, aStatus, aInfo);
+	}
+EXPORT_C void RPacketContext::NotifyConnectionInfoChange(TRequestStatus& aStatus, TDes8& aInfo) const
+// This function may be called by the client.
+/**
+	Allows a client to be notified whenever the connection information changes
+	and gets the updated connection information.
+	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.
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide
+	error codes.
+	@param aInfo TConnectionInfoV1 or any later derived versions supplied by the client packaged
+	as a TPckg<TConnectionInfoVx>.
+	N.B. only supported if telephony was built with SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW macro
+@capability None
+*/
+	{
+	Get(EPacketContextNotifyConnectionInfoChange, aStatus, aInfo);
+	}
+EXPORT_C TInt RPacketContext::GetLastErrorCause(TInt& aError) const
+/**
+	Gets the most recent error to have occurred. This may be used, for instance,
+	to retrieve which error caused PPP to close down prematurely.
+	This function may be called by the client.
+	@param aError On return, the last error received or generated by the TSY.
+	@return KErrNone if successful, a system-wide error code if not.
+@capability None
+*/
+	{
+	TPckg<TInt> ptr1(aError);
+	return Get(EPacketContextGetLastErrorCause, ptr1);
+	}
+EXPORT_C void RPacketContext::InitialiseContext(TRequestStatus& aStatus, TDes8& aDataChannelV2) const
+//This function may be called by the client.
+/**
+	Enables asynchronous resource reservation for a new primary or secondary context at the creation phase,
+	since version 2 of the API.
+	This is an asynchronous function.
+	Supersedes the LoanCommPort() and RecoverCommPort() methods, which are now deprecated.
+	This new method enables asynchronous resource reservation for a new primary or
+	secondary context at the creation phase.
+	The InitialiseContext() method still contains the information that was previously in the
+	LoanCommPort() method, i.e. details of the comm port to be used for sending/receiving user
+	data. It however has an additional member which will return any additional information
+	generated by context creation.
+	Introduced in v7.0S
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide
+	error codes.
+	@param aDataChannelV2 Reference to a TDataChannelV2 class packaged inside a TPckg<> class.
+	The TDataChannelV2 class contains the members of the struct used previously by the
+	deprecated LoanCommPort() method as well as an additional member which will now return
+	technical information generated when a context is created, for instance, a context name or
+	id. This name/id is different from that assigned by the TSY when the OpenNewContext() or
+	OpenNewSecondaryContext() methods are called.
+@capability NetworkServices
+*/
+	{
+	Get(EPacketContextInitialiseContext, aStatus, aDataChannelV2);
+	}
+EXPORT_C void RPacketContext::EnumeratePacketFilters(TRequestStatus& aStatus, TInt& aCount) const
+/**
+	This asynchronous method may be called by the client application.
+	It returns the number of defined packet filters in the Traffic Flow Template (TFT) associated
+	with this context since version 2 of the API.
+	Supported from v7.0S.
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.
+	@param aCount Number of packet filters in the TFT.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1 = iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumeratePacketFilters, aCount);
+	Get(EPacketContextEnumeratePacketFilters, aStatus, ptr1);
+	}
+EXPORT_C void RPacketContext::GetPacketFilterInfo(TRequestStatus& aStatus, TInt aIndex, TDes8& aPacketFilterInfo) const
+/**
+	This asynchronous method may be called by the client application.
+	Retrieves information about the packet filter specified by the aIndex parameter since version 2 of this API.
+	It is usual to use this function in conjunction with the EnumeratePacketFilters() method,
+	which returns the current number of defined packet filters in the TFT in its 'aCount' argument.
+	Supported from v7.0S
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.
+	@param aIndex Specifies packet filter for which information is to be retrieved.
+	The valid range for aIndex will be between 0 and (n-1) where n is the number returned in
+	aCount. If an invalid index is specified the method will return KErrArgument in its aStatus.
+	@param aPacketFilterInfo	Reference to a TPacketFilterV2 class packaged inside a TPckg<> class.
+@capability ReadDeviceData
+@capability NetworkServices
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketContextPtrHolder->iGetPacketFilterInfoIndex = aIndex;
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetPacketFilterInfo,iEtelPacketContextPtrHolder->iGetPacketFilterInfoIndex);
+	Get(EPacketContextGetPacketFilterInfo, aStatus, ptr1, aPacketFilterInfo);
+	}
+EXPORT_C void RPacketContext::AddPacketFilter(TRequestStatus& aStatus, const TDesC8& aPacketFilterInfo) const
+/**
+	This asychronous method may be called by the client application.
+	It sets up a packet filter in the TFT belonging to this context with the ID specified
+	in the packet filter information since version 2 of this API.
+	Supported from v7.0S .
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.
+	@param aPacketFilterInfo	Reference to a TPacketFilterV2 class packaged inside a TPckg<> class.
+@capability WriteDeviceData
+@capability NetworkServices
+*/
+	{
+	Set(EPacketContextAddPacketFilter, aStatus, aPacketFilterInfo);
+	}
+EXPORT_C void RPacketContext::RemovePacketFilter(TRequestStatus& aStatus, TInt aId) const
+/**
+	This asynchronous method may be called by the client application.
+	Removes a packet filter from the TFT belonging to this context, since version 2 of the API.
+	Supported from v7.0S
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.
+	@param aId Specifies the packet filter.
+@capability WriteDeviceData
+@capability NetworkServices
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketContextPtrHolder->iRemovePacketFilterId = aId;
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotRemovePacketFilter,iEtelPacketContextPtrHolder->iRemovePacketFilterId);
+	Set(EPacketContextRemovePacketFilter, aStatus, ptr1);
+	}
+EXPORT_C void RPacketContext::ModifyActiveContext(TRequestStatus& aStatus) const
+/**
+	This asynchronous method may be called by the client application.
+	It invokes an MS-initiated  modification of an active context in the network since version 2 of the API.
+	The client must previously have altered either the requested QoS profile of the context
+	and/or the TFT whilst the context was active before calling this method.
+	Supported from v7.0S
+	@param aStatus On return, KErrNone if successful, otherwise another of the system-wide error codes.
+@capability NetworkServices
+*/
+	{
+	Blank(EPacketContextModifyActiveContext, aStatus);
+	}
+EXPORT_C TInt RPacketContext::OpenNewSecondaryContext(RPacketService& aPacketService, const TDesC& aExistingContextName, TDes& aNewContextName)
+// This function may be called by the client application.
+/**
+	Creates a new secondary context from an existing context (either primary or secondary)
+	since version 2 of the API.
+	The configuration of the existing context is used by the new one so the client need not
+	call the RPacketContext::SetConfig() method.
+	Immediately after the creation of the newly created secondary context, a client must -
+	a) ensure that they specify the requested QoS using an RPacketQoS object;
+	b) add a packet filter to the secondary object. This assumes that there already exists a
+	primary or secondary context for this NIF without a TFT. If this is not the case, it is
+	not mandatory that a packet filter is added to this new secondary context before activation.
+	The TSY will return KErrNotSupported if it does not support secondary contexts.
+	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.
+	There is a global mutex around this method and the RPacketService::OpenNewContext() method.
+	There is a potential thread timing issue 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.
+	@param aPacketService 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 aExistingContextName : Name of the existing context which is to spawn a secondary
+	context.
+	@param aNewContextName : New Secondary context name is assigned by the TSY.
+@capability None
+*/
+	{
+	RSessionBase* session=&aPacketService.SessionHandle();
+	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle));
+	TRAPD(ret,ConstructL());
+	if (ret)
+		{
+		Destruct();
+		return ret;
+		}
+	TInt subSessionHandle=aPacketService.SubSessionHandle();
+	__ASSERT_ALWAYS(subSessionHandle!=0,PanicClient(EEtelPanicNullHandle));
+	TPtrC name(KETelNewContextName);	// The server knows to ask the TSY for a new name.
+	SetSessionHandle(*session);
+	aPacketService.iMutex.Wait();					// wait for access to the mutex
+	TInt retVal=aPacketService.PrepareOpenSecondary(aExistingContextName);
+	if (retVal)
+		{
+		aPacketService.iMutex.Signal();				// Unblock the mutex
+		return retVal;
+		}
+	TIpcArgs args(&name,&aNewContextName,subSessionHandle);
+	ret = CreateSubSession(*session,EEtelOpenFromSubSession,args);
+	aPacketService.iMutex.Signal();					// Unblock the mutex
+	if (ret)
+		Destruct();
+	return ret;
+	}
+EXPORT_C RPacketContext::TContextConfigGPRS::TContextConfigGPRS()
+: TPacketDataConfigBase(), iPdpType(EPdpTypeIPv4), iAccessPointName(NULL), iPdpAddress(NULL),
+iPdpCompression(0), iAnonymousAccessReqd(ENotRequired), iUseEdge(EFalse),
+iProtocolConfigOption(), iNWIContext(EFalse)
+/**
+	Standard constructor. Sets the member data values to the defaults.
+	This class contains member data compatible with parameters required for configuring a
+	context on the GPRS and UMTS packet networks.
+	The iExtensionId parameter, set automatically by ETel, is used by the TSY when unpacking this
+	class from a TPckg<> to indicate it is to be unpacked as a TContextConfigGPRS class.
+*/
+	{
+	iExtensionId = KConfigGPRS;
+	};
+EXPORT_C RPacketContext::TContextConfigR99_R4::TContextConfigR99_R4()
+: TPacketDataConfigBase(), iPdpType(EPdpTypeIPv4), iAccessPointName(NULL), iPdpAddress(NULL),
+iUseEdge(EFalse), iProtocolConfigOption(), iNWIContext(EFalse), iPFI(EBestEffort)
+/**
+	Standard constructor. Sets the member data values to the defaults.
+	This class contains member data compatible with parameters required for configuring a
+	context on the R99/R4 packet networks.
+	The iExtensionId parameter, set automatically by ETel, is used by the TSY when unpacking this
+	class from a TPckg<> to indicate it is to be unpacked as a TContextConfigR99_R4 class.
+*/
+	{
+	iExtensionId = KConfigRel99Rel4;
+	};
+EXPORT_C RPacketContext::TContextConfigCDMA::TContextConfigCDMA()
+: TPacketDataConfigBase(), iServiceOption(KLowSpeedData), iProtocolType(EPdpTypePPP)
+/**
+	Standard constructor. Sets all the member data values to the defaults.
+	The iExtensionId parameter, set automatically by ETel, is used by the TSY when unpacking this
+	class from a TPckg<> to indicate it is to be unpacked as a TContextConfigCDMA class.
+	The Service option is set to KLowSpeedData (Default: Assume IWF/PDSN supports 2G service
+	option. (exact value of "LowSpeedData" is to be decided by TSY implementation)).
+	The Protocol type is set to EPdpTypePPP (Default: Assume IWF/PDSN supports PPP link layer)
+*/
+	{
+	iExtensionId = KConfigCDMA;
+	};
+EXPORT_C RPacketContext::TConnectionInfoV1::TConnectionInfoV1()
+: TConnectionInfoBase(), iHSDPACategory(0), iHSUPACategory(0)
+/**
+	Standard constructor. Sets the member data values to the defaults.
+	This class contains miscellaneous information about packet data connection.
+	The iExtensionId parameter, set automatically by ETel, is used by the TSY
+	when unpacking this class from a TPckg<> to indicate it is to be unpacked
+	as a TConnectionInfoV1 class.
+*/
+	{
+	iExtensionId = KConnectionInfoV1;
+	iValid = 0;
+	};
+EXPORT_C void RPacketContext::GetDnsInfo(TRequestStatus& aStatus, TDes8& aDnsInfo) const
+/**
+	Extracts DNS server names from the context since version 2 of the API.
+	Supported from v7.0S.
+	@param aStatus TRequestStatus object with which error code is returned
+	@param aDnsInfo Packaged TDnsInfoV2 object.
+	GetDNSInfo() is needed when the client uses dynamic IPv4 PDP addresses.
+	After the context is activated the client needs to know the actual primary
+	and secondary DNS addresses to use when sending packet data. As the network
+	may have supplied these addresses there is a need for an API method to get
+	these addresses from the TSY.
+@capability ReadDeviceData
+*/
+	{
+		__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+		Get(EPacketContextGetDNSInfo, aStatus, aDnsInfo);
+	};
+EXPORT_C RPacketContext::TDnsInfoV2::TDnsInfoV2()
+: TPacketBase(), iPrimaryDns(0), iSecondaryDns(0)
+/**
+	Standard constructor since version 2 of the API.
+	@see KETelExtPcktV2
+*/
+	{
+	iExtensionId = KETelExtPcktV2;
+	}
+EXPORT_C RPacketContext::TProtocolConfigOptionV2::TProtocolConfigOptionV2()
+: TPacketBase(), iChallenge(0), iResponse(0), iId(0), iDnsAddresses(),
+iMiscBuffer(0)
+/**
+	Constructor for TProtocolConfigOptionV2 class
+	This class will hold authentication data encapsulated in TAuthInfo as well as further data that
+	may be required for CHAP protocol authentication, such a challenge and response
+*/
+	{
+	iExtensionId = KETelExtPcktV2;
+	//
+	// Initialise the TAuthInfo structure...
+	//
+	iAuthInfo.iProtocol = EProtocolNone;
+	iAuthInfo.iUsername.Zero();
+	iAuthInfo.iPassword.Zero();
+	};
+EXPORT_C RPacketContext::TDataChannelV2::TDataChannelV2()
+: TPacketBase(), iCsy(NULL), iPort(NULL), iChannelId(NULL)
+/**
+	Standard constructor since version 2 of the API.
+	The member data are initialized to NULL. The client should set
+	the data to valid values. Note that the iCsy and iPort data
+	members are deprecated.
+*/
+	{
+	iExtensionId = KETelExtPcktV2;
+	};
+EXPORT_C RPacketContext::TPacketFilterV2::TPacketFilterV2()
+: TPacketBase(), iId(0), iEvaluationPrecedenceIndex(0), iProtocolNumberOrNextHeader(0), iSrcPortMin(0),
+iSrcPortMax(0), iDestPortMin(0), iDestPortMax(0), iIPSecSPI(0), iTOSorTrafficClass(0),
+iFlowLabel(0)
+/**
+	Standard constructor since version 2 of the API.
+	All the member data are initialized to zero. The client should set the required parameters
+	to valid values.
+	Some of the parameters are optional while others are mutually exclusive. Only the Packet
+	filter identifier (iId) and the precedence index (iEvaluationPrecedenceIndex) are
+	mandatory.
+*/
+	{
+	iExtensionId = KETelExtPcktV2;
+	TInt i;							//< loop variable
+	// Initialize the Domain Source address and Domain Subnet Mask
+	for (i=0; i<KIPAddressSize; i++)
+		{
+		iSrcAddr[i] = 0;			//< Optional parameter. Zero value implies Not applicable
+		iSrcAddrSubnetMask[i] = 0;	//< Optional parameter. Zero value implies Not applicable
+		}
+	};
+EXPORT_C void RPacketContext::CreateNewTFT(TRequestStatus& aStatus, const TInt aSize) const
+/**
+	This asynchronous method may be called by the client application.
+	Creates a new Traffic Flow Template.
+	@param aStatus TRequestStatus reference, enables asynchronous function call.
+	@param aSize Number of filters that the TFT contains.
+@capability NetworkServices
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketContextPtrHolder->iCreateTFTSize = aSize;
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotCreateTFT, iEtelPacketContextPtrHolder->iCreateTFTSize);
+	Set(EPacketContextCreateNewTFT, aStatus, ptr1);
+	}
+EXPORT_C void RPacketContext::DeleteTFT(TRequestStatus& aStatus) const
+/**
+	This asynchronous method may be called by the client application.
+	Deletes the existing traffic flow template (including all filters) for this context object.
+	@param aStatus TRequestStatus reference, enables asynchronous function call.
+@capability NetworkServices
+*/
+	{
+	Blank(EPacketContextDeleteTFT, aStatus);
+	}
+EXPORT_C RPacketContext::TPacketFilterV3::TPacketFilterV3(TPacketFilterType aType)
+		:iType(aType), iAllowedDataBitmap(0), iPresentDataBitmap(0)
+/**
+	Standard Constructor: Version 3 of the API
+	iType is set to aType which is passed as parameter and can be of the type EPacketFilterTypeOne,
+	EPacketFilterTypeTwo or EPacketFilterTypeThree.
+	iPresentDataBitmap is initialised to zero.
+	iAllowedDataBitmap is set to a valid combination of TPacketFilterV3DataBitmapPos according to
+	aType.
+	@param aType TPacketFilterType - Can take any of the following values: EPacketFilterTypeOne,
+	EPacketFilterTypeTwo or EPacketFilterTypeThree.
+*/
+	{
+	iExtensionId = KETelExtPcktV3;
+	iAllowedDataBitmap = EPacketFilterSrcAddr | EPacketFilterSrcAddrSubnetMask;
+	switch (iType)
+		{
+		case EPacketFilterTypeOne:
+			{
+			iAllowedDataBitmap|=
+				(
+				EPacketFilterProtocolNumberOrNextHeader |
+				EPacketFilterSrcPortMin | EPacketFilterSrcPortMax |
+				EPacketFilterDestPortMin | EPacketFilterDestPortMax |
+				EPacketFilterTOSorTrafficClass
+				);
+			break;
+			}
+		case EPacketFilterTypeTwo:
+			{
+			iAllowedDataBitmap|=
+				(
+			 	EPacketFilterProtocolNumberOrNextHeader |
+			 	EPacketFilterIPSecSPI |
+				EPacketFilterTOSorTrafficClass
+				);
+			break;
+			}
+		case EPacketFilterTypeThree:
+			{
+			iAllowedDataBitmap|=
+				(
+				EPacketFilterTOSorTrafficClass |
+				EPacketFilterFlowLabel
+				);
+			break;
+			}
+		default:
+		 	break;
+		}
+	}
+EXPORT_C RPacketContext::TPacketFilterV3::TPacketFilterV3()
+		:iType(EPacketFilterTypeUnknown), iAllowedDataBitmap(0), iPresentDataBitmap(0)
+/**
+	Default Constructor
+	iType is set to EPacketFilterTypeUnknown
+*/
+	{
+		iExtensionId = KETelExtPcktV3;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetSrcAddr(TIPAddress &aSrcAddr)
+/**
+	This method may be called by the client application.
+	Sets the iSrcAddr to a SrcAddr only if a valid combination of bitmap is present.
+	@param aSrcAddr TIPAddress value to be set.
+*/
+	{
+	if(!(EPacketFilterSrcAddr & iAllowedDataBitmap))
+		return EFalse;
+	Mem::Copy(iSrcAddr,aSrcAddr,sizeof(TIPAddress));
+	iPresentDataBitmap |= EPacketFilterSrcAddr;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetSrcAddrSubnetMask(TIPAddress &aSrcAddrSubnetMask)
+/**
+	This method may be called by the client application.
+	Sets the iSrcAddrSubnetMask to aSrcAddrSubnetMask only if a valid combination of bitmap is present.
+	@param aSrcAddrSubnetMask TIPAddress value to be set.
+*/
+	{
+	if(!(EPacketFilterSrcAddrSubnetMask &	iAllowedDataBitmap))
+		return EFalse;
+	Mem::Copy(iSrcAddrSubnetMask,aSrcAddrSubnetMask,sizeof(TIPAddress));
+	iPresentDataBitmap |= EPacketFilterSrcAddrSubnetMask;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetProtocolNumberOrNextHeader(TInt aProtocolNumberOrNextHeader)
+/**
+	This method may be called by the client application.
+	Sets the iProtocolNumberOrNextHeader to aProtocolNumberOrNextHeader only if a valid combination of bitmap is present.
+	@param aProtocolNumberOrNextHeader TInt value to be set.
+*/
+	{
+	if(!(EPacketFilterProtocolNumberOrNextHeader & iAllowedDataBitmap))
+		return EFalse;
+	iProtocolNumberOrNextHeader=aProtocolNumberOrNextHeader;
+	iPresentDataBitmap |= EPacketFilterProtocolNumberOrNextHeader;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetSrcPortMin(TInt aSrcPortMin)
+/**
+	This method may be called by the client application.
+	Sets the iSrcPortMin to aSrcPortMin only if a valid combination of bitmap is present.
+	@param aSrcPortMin TInt value to be set.
+*/
+	{
+	if(!(EPacketFilterSrcPortMin & iAllowedDataBitmap))
+		return EFalse;
+	iSrcPortMin=aSrcPortMin;
+	iPresentDataBitmap |= EPacketFilterSrcPortMin;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetSrcPortMax(TInt aSrcPortMax)
+/**
+	This method may be called by the client application.
+	Sets the iSrcPortMax to aSrcPortMax only if a valid combination of bitmap is present.
+	@param aSrcPortMax TInt value to be set.
+*/
+	{
+	if(!(EPacketFilterSrcPortMax & iAllowedDataBitmap))
+		return EFalse;
+	iSrcPortMax=aSrcPortMax;
+	iPresentDataBitmap |= EPacketFilterSrcPortMax;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetDestPortMin(TInt aDestPortMin)
+/**
+	This method may be called by the client application.
+	Sets the iDestPortMin to aDestPortMin only if a valid combination of bitmap is present.
+	@param aDestPortMin TInt value to be set.
+*/
+	{
+	if(!(EPacketFilterDestPortMin & iAllowedDataBitmap))
+		return EFalse;
+	iDestPortMin=aDestPortMin;
+	iPresentDataBitmap |= EPacketFilterDestPortMin;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetDestPortMax(TInt aDestPortMax)
+/**
+	This method may be called by the client application.
+	Sets the iDestPortMax to aDestPortMax only if a valid combination of bitmap is present.
+	@param aDestPortMax TInt value to be set.
+*/
+	{
+	if(!(EPacketFilterDestPortMax &	iAllowedDataBitmap))
+		return EFalse;
+	iDestPortMax=aDestPortMax;
+	iPresentDataBitmap |= EPacketFilterDestPortMax;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetSPI(TUint32 aIPSecSPI)
+/**
+	This method may be called by the client application.
+	Sets the iIPSecSPI to aIPSecSPI only if a valid combination of bitmap is present.
+	@param aIPSecSPI TUint32 value to be set.
+*/
+	{
+	if(!(EPacketFilterIPSecSPI &	iAllowedDataBitmap))
+		return EFalse;
+	iIPSecSPI=aIPSecSPI;
+	iPresentDataBitmap |= EPacketFilterIPSecSPI;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetTOSorTrafficClass(TUint16 aTOSorTrafficClass)
+/**
+	This method may be called by the client application.
+	Sets the iTOSorTrafficClass to aTOSorTrafficClass only if a valid combination of bitmap is present.
+	@param aTOSorTrafficClass TUint16 value to be set.
+*/
+	{
+	if(!(EPacketFilterTOSorTrafficClass &	iAllowedDataBitmap))
+		return EFalse;
+	iTOSorTrafficClass=aTOSorTrafficClass;
+	iPresentDataBitmap |= EPacketFilterTOSorTrafficClass;
+	return ETrue;
+	}
+EXPORT_C TBool RPacketContext::TPacketFilterV3::SetFlowLabel(TUint32 aFlowLabel)
+/**
+	This method may be called by the client application.
+	Sets the iFlowLabel to aFlowLabel only if a valid combination of bitmap is present.
+	@param aFlowLabel TUint32 value to be set.
+*/
+	{
+	if(!(EPacketFilterFlowLabel &	iAllowedDataBitmap))
+		return EFalse;
+	iFlowLabel=aFlowLabel;
+	iPresentDataBitmap|=EPacketFilterFlowLabel ;
+	return ETrue;
+	}
+RPacketContext::CTFTMediaAuthorizationV3::CTFTMediaAuthorizationV3()
+{
+	iExtensionId = KETelExtPcktV3;
+}
+EXPORT_C RPacketContext::CTFTMediaAuthorizationV3* RPacketContext::CTFTMediaAuthorizationV3::NewL()
+{
+	CTFTMediaAuthorizationV3* self = new(ELeave) CTFTMediaAuthorizationV3;
+	return self;
+}
+EXPORT_C RPacketContext::CTFTMediaAuthorizationV3::~CTFTMediaAuthorizationV3()
+{
+	iFlowIds.Reset();
+	iFlowIds.Close();
+}
+EXPORT_C void RPacketContext::CTFTMediaAuthorizationV3::ExternalizeL(HBufC8*& aBuffer) const
+{
+/**
+Serialize data to the buffer.
+If aBuffer points to already allocated memory, client has to be aware that it won't have
+access to this location anymore as method reallocates memory and updates aBuffer accordingly.
+Therefore, value passed in should not be freed upon completion of the method neither put onto
+the cleanup stack before method is invoked.
+After completion of the API, it's clients responsibility to control life scope
+of allocated memory passed back via aBuffer.
+@param aBuffer Heap-based buffer which will contain the serialized data.
+*/
+	TUint uintLen=sizeof(TUint);
+	TUint uintLen16 = sizeof(TUint16);
+	TUint size= uintLen/* extension id*/ + uintLen /* Authorization Token length*/ + iAuthorizationToken.Length();
+	TUint count=iFlowIds.Count();
+	size+=uintLen; /** number of iFlowIds elements*/
+	size+= count*(uintLen16+uintLen16);
+	if(aBuffer)
+		{
+	 	delete aBuffer;
+	 	aBuffer=NULL;
+	 	}
+	aBuffer=HBufC8::NewL(size);
+	aBuffer->Des().SetLength(size);
+	TInt cursor(0);
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),(const TUint8*)(&iExtensionId),uintLen);
+	cursor+=uintLen;
+	TUint len=iAuthorizationToken.Length();
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),&len,uintLen);
+	cursor+=uintLen;
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),iAuthorizationToken.Ptr(),len);
+	cursor+=len;
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),(const TUint8* )(&count),uintLen);
+	cursor+=uintLen;
+	for(TUint i=0;i<count;i++)
+		{
+		Mem::Copy((TUint16*)(aBuffer->Des().Ptr()+cursor),(const TUint16* )(&iFlowIds[i].iMediaComponentNumber),uintLen16);
+		cursor+=uintLen16;
+		Mem::Copy((TUint16*)(aBuffer->Des().Ptr()+cursor),(const TUint16* )(&iFlowIds[i].iIPFlowNumber),uintLen16);
+		cursor+=uintLen16;
+		}
+}
+EXPORT_C void RPacketContext::CTFTMediaAuthorizationV3::InternalizeL(TDes8& aBuffer)
+{
+	iFlowIds.Reset();
+	TUint uintLen=sizeof(TUint);
+	TInt cursor=0;
+	if(aBuffer.Length() < cursor + uintLen)
+		User::Leave(KErrOverflow);
+	Mem::Copy(&iExtensionId,aBuffer.Ptr(),uintLen);
+	cursor+=uintLen;
+	if(aBuffer.Length() < cursor + uintLen)
+		User::Leave(KErrOverflow);
+	TInt len(0);
+	Mem::Copy(&len,aBuffer.Ptr()+cursor,uintLen);
+	cursor+=uintLen;
+	if(aBuffer.Length() < cursor + len)
+		User::Leave(KErrOverflow);
+	iAuthorizationToken.Copy(aBuffer.MidTPtr(cursor,len));
+	cursor+=len;
+	if(aBuffer.Length() < cursor + uintLen)
+		User::Leave(KErrOverflow);
+	TUint count(0);
+	Mem::Copy(&count,aBuffer.Ptr()+cursor,uintLen);
+	cursor+=uintLen;
+	RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier flowIdentifier;
+	TUint uintLen16 = sizeof(TUint16);
+	for(TUint i=0;i<count;i++)
+		{
+		if(aBuffer.Length() < cursor + uintLen16 + uintLen16)
+			User::Leave(KErrOverflow);
+		Mem::Copy(&flowIdentifier.iMediaComponentNumber,aBuffer.Ptr()+cursor,uintLen16);
+		cursor+=uintLen16;
+		Mem::Copy(&flowIdentifier.iIPFlowNumber,aBuffer.Ptr()+cursor,uintLen16);
+		cursor+=uintLen16;
+		iFlowIds.Append(flowIdentifier);
+		}
+}
+EXPORT_C TUint RPacketContext::CTFTMediaAuthorizationV3::ExtensionId() const
+{
+	return iExtensionId;
+}
+EXPORT_C void RPacketContext::AddMediaAuthorizationL(TRequestStatus& aStatus, CTFTMediaAuthorizationV3& aMediaAuthorization) const
+/**
+	Adds a new set of Authorization Token and Flow Identifiers to the packet context object.
+	This asynchronous method may be called by the client application.
+	@param aStatus TRequestStatus reference, enables asynchronous function call.
+	@param aMediaAuthorization a reference to a CTFTMediaAuthorizationV3 object containing the data that is to be added.
+@capability NetworkServices
+@capability WriteDeviceData
+*/
+{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	delete iEtelPacketContextPtrHolder->iStoreNetworkBuf;
+	iEtelPacketContextPtrHolder->iStoreNetworkBuf = NULL;
+	aMediaAuthorization.ExternalizeL(iEtelPacketContextPtrHolder->iStoreNetworkBuf);
+	(iEtelPacketContextPtrHolder->iStoreNetworkPtr).Set((iEtelPacketContextPtrHolder->iStoreNetworkBuf)->Des());
+	Set(EPacketAddMediaAuthorization,aStatus,iEtelPacketContextPtrHolder->iStoreNetworkPtr);
+}
+EXPORT_C void RPacketContext::RemoveMediaAuthorization(TRequestStatus& aStatus, TAuthorizationToken& aAuthorizationToken) const
+/**
+	Removes the Authorization Token and Flow Identifiers set from the packet context object. This is identified by aAuthorizationToken.
+	This asynchronous method may be called by the client application.
+	@param aStatus TRequestStatus reference, enables asynchronous function call.
+	@param aAuthorizationToken identifier to the Authorization Token that is to be removed.
+@capability NetworkServices
+@capability WriteDeviceData
+*/
+{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotRemoveMediaAuthorization,aAuthorizationToken);
+	Set(EPacketRemoveMediaAuthorization, aStatus, ptr1);
+}
+EXPORT_C RPacketContext::TContextConfig_R5::TContextConfig_R5()
+: TContextConfigR99_R4(), iPdpHeaderCompression(ENoHeaderCompression), iPdpDataCompression(ENoDataCompression)
+/**
+	Standard constructor. Sets the member data values to the defaults.
+	This class contains member data compatible with parameters required for configuring a
+	context on the R5 packet networks.
+*/
+	{
+	iExtensionId = KConfigRel5;
+	};
+/***********************************************************************************/
+//
+// RPacketService
+//
+/***********************************************************************************/
+EXPORT_C RPacketService::RPacketService()
+	:iEtelPacketPtrHolder(NULL)
+/** Standard constructor. */
+	{
+	}
+EXPORT_C void RPacketService::ConstructL()
+/**
+	ConstructL for the RPacketService class
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));
+	iEtelPacketPtrHolder = CPacketPtrHolder::NewL(CEtelPacketPtrHolder::EMaxNumPacketPtrSlots, CEtelPacketPtrHolder::EMaxNumPacketPtrCSlots);
+	}
+EXPORT_C void RPacketService::Destruct()
+/**
+	Destruct() method for the RPacketService class
+@capability None
+*/
+	{
+	delete iEtelPacketPtrHolder;
+	iEtelPacketPtrHolder = NULL;
+	}
+EXPORT_C TInt RPacketService::Open(RPhone& aPhone)
+// This function may be called by the client.
+/**
+	Creates a RPacketService subsession from an existing RPhone session.
+	An opened RPacketService must be closed explicitily by calling Close() to
+	prevent a resource (memory) leak.
+	@param aPhone A reference to an existing RPhone session the client has previously
+	created.
+	@return KErrNone if successful.
+@capability None
+*/
+	{
+	RSessionBase* session=&aPhone.SessionHandle();
+	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle));
+	TInt subSessionHandle=aPhone.SubSessionHandle();
+	__ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle));
+	TRAPD(ret,ConstructL());
+	if (ret)
+		return ret;
+	SetSessionHandle(*session);
+	TIpcArgs args(&KPacketName,TIpcArgs::ENothing,subSessionHandle);
+	ret= CreateSubSession(*session,EEtelOpenFromSubSession,args);
+	if (ret)
+		{
+		Destruct();
+		return ret;
+		}
+// initialise synchronisation mutex in EKA2
+		TInt mutexHandle= SendReceive(EEtelGlobalKernelObjectHandle);
+		if(mutexHandle <=0)
+		{
+		 Destruct();
+		 return KErrBadHandle;
+		}
+		ret= iMutex.SetReturnedHandle(mutexHandle);
+		if( ret != KErrNone)
+			Destruct();
+	return ret;
+	}
+EXPORT_C void RPacketService::Close()
+// This function may be called by the client.
+/**
+	Closes the RPacketService subsession.
+	An opened RPacketService must be closed explicitily by calling Close() to
+	prevent a resource (memory) leak.
+@capability None
+*/
+	{
+	iMutex.Close();
+	CloseSubSession(EEtelClose);
+	Destruct();
+	}
+EXPORT_C void RPacketService::NotifyContextAdded(TRequestStatus& aStatus, TDes& aContextId) const
+//This function may be called by the client.
+/**
+	Notifies the client whenever a new context (RPacketContext) is configured
+	on the phone by a client using RPacketContext::SetConfig().
+	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(EPacketNotifyContextAdded) to cancel
+	a previously placed asynchronous NotifyContextAdded() request.
+	@param aStatus On completion, KErrNone if successful, a system-wide error
+	code if not.
+	@param aContextId On completion, the name of the newly added context. The name
+	is assigned by the TSY and uniquely identifies the particular context.
+@capability None
+*/
+	{
+	Get(EPacketNotifyContextAdded,aStatus,aContextId);
+	}
+EXPORT_C void RPacketService::Attach(TRequestStatus& aStatus) const
+// This function may be called by the client.
+/**
+	Causes the phone to attempt an attach to the packet network, if it is not already
+	attached.
+	This is an asynchronous function since attachment may take anything up to one
+	minute in the worst case scenario.
+	Attachment may take anything up to one minute in the worst case scenario.
+	It is not often necessary to use this function as there is a separate setting
+	to tell the phone either to attach at start-up, or to attach when a context
+	is created. It is intended that this function only be utilized if the user
+	has an option to choose exactly when to attach and detach.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketAttach) to cancel a previously
+	placed asynchronous Attach() request.
+	@param aStatus On completion, KErrNone if successful, KErrAlreadyExists if
+	the phone was already attached to a packet network, KErrPacketNetworkFailure
+	if the phone cannot attach.
+@capability NetworkServices
+*/
+	{
+	Blank(EPacketAttach,aStatus);
+	}
+EXPORT_C void RPacketService::Detach(TRequestStatus& aStatus) const
+//This function may be called by the client.
+/**
+	Causes the phone to attempt to detach from the packet network, if it is not already.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketDetach) to cancel a previously
+	placed asynchronous Detach() request.
+	@param aStatus On completion, KErrNone if successful, KErrAlreadyExists if
+	the phone was already detached, KErrInUse if at least one context is active.
+@capability NetworkServices
+*/
+	{
+	Blank(EPacketDetach, aStatus);
+	}
+EXPORT_C TInt RPacketService::GetStatus(TStatus& aPacketStatus) const
+// This function may be called by the client.
+/**
+	Gets the status of the current packet service.
+	This is a synchronous function.
+	@param aPacketStatus On return, the current packet service status.
+	@return KErrNone if successful, otherwise another of the system wide error codes.
+@capability None
+*/
+	{
+	TPckg<TStatus> ptr1(aPacketStatus);
+	return Get(EPacketGetStatus, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyStatusChange(TRequestStatus& aStatus,TStatus& aPacketStatus) const
+//This function may be called by the client.
+/**
+	Allows a client to be notified of a change in the status of the connection
+	to the packet service.
+	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(EPacketNotifyStatusChange) to cancel
+	a previously placed asynchronous NotifyStatusChange() request.
+	@param aStatus On completion, KErrNone if successful, otherwise another of the system wide error codes.
+	@param aPacketStatus On completion, the new packet status
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotPacketStatus,aPacketStatus);
+	Get(EPacketNotifyStatusChange,aStatus,ptr1);
+	}
+EXPORT_C void RPacketService::NotifyContextActivationRequested(TRequestStatus& aStatus, TDes8& aContextParameters) const
+/**
+	Completes when the phone receives a request from the packet network to activate
+	a PDP context.
+	This is an asynchronous function.
+	Depending on the type of network, the aContextParameters may contain the PDP
+	type requested, the PDP address for this context, and possibly the Access
+	Point Name (APN) of the gateway to connect to.
+	To determine how to correctly unpack the aContextParameters descriptor inside the
+	TSY, the TSY must first cast the descriptor to a TPacketDataConfigBase pointer and
+	check whether ExtensionId() returns KConfigGPRS, KConfigCDMA or KConfigRel99Rel4.
+	The TSY will then cast the descriptor to the correct TPacketDataConfigBase-derived
+	class.
+	Once the notification completes, the client must then re-post the notification
+	if they wish to continue receiving further notifications.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketNotifyContextActivationRequested)
+	to cancel a previously placed asynchronous NotifyContextActivationRequested()
+	request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aContextParameters A TContextConfigXXX context configuration object packaged
+	as a TPckg<TContextConfigXXX>.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	Get(EPacketNotifyContextActivationRequested, aStatus, aContextParameters);
+	}
+EXPORT_C void RPacketService::RejectActivationRequest(TRequestStatus& aStatus) const
+/**
+	Causes the phone to reject the network's request for a PDP context activation.
+	This is an asynchronous function.
+	There is no corresponding "accept" message for the phone to send. To accept,
+	the phone should simply begin to activate a PDP context with the appropriate
+	IP address before the network's timer expires. On GPRS, this timer last between
+	5 and 8 seconds, but may effectively last between around 25 and 40 seconds,
+	as the specifications state that the activation request should be re-sent
+	up to five times.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketRejectActivationRequest)
+	to cancel a previously placed asynchronous RejectActivationRequest() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+@capability NetworkServices
+*/
+	{
+	Blank(EPacketRejectActivationRequest, aStatus);
+	}
+EXPORT_C void RPacketService::EnumerateContexts(TRequestStatus& aStatus, TInt& aCount, TInt& aMaxAllowed) const
+//This function may be called by the client.
+/**
+	Retrieves both the number of opened contexts in the TSY, whether active or inactive, and
+	the maximum possible number of contexts.
+	This is an asynchronous function.
+	Allows a client to determine whether they can open a new context.
+	The maximum number of possible contexts is not the maximum number of simultaneously
+	active contexts, but the total number allowed. (The maximum possible number
+	of simultaneously active contexts is currently limited to 1). Clients are
+	thus able to determine whether they can open a new context or not.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketEnumerateContexts) to cancel
+	a previously placed asynchronous EnumerateContexts() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aCount On completion, the number of opened contexts existing in the TSY.
+	@param aMaxAllowed On completion, the maximum number of opened contexts that
+	are allowed in the TSY, or -1 if the maximum number of opened contexts is
+	not available.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateCount,aCount);
+	TPtr8& ptr2=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateMaxCount,aMaxAllowed);
+	Get(EPacketEnumerateContexts, aStatus, ptr1, ptr2);
+	}
+EXPORT_C void RPacketService::GetContextInfo(TRequestStatus& aStatus,TInt aIndex,TContextInfo& aInfo) const
+/**
+	Retrieves information about a particular context.
+	It is usual to use this function in conjunction with the EnumerateContexts()
+	function, which returns the current number of opened contexts.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketGetContextInfo) to cancel
+	a previously placed asynchronous GetContextInfo() request.
+	@param aStatus On completion, KErrNone if successful, or KErrArgument if the aIndex is invalid.
+	@param aIndex The index of the context to get. The valid range for aIndex will be between 0 and
+	(n-1) where n is the number of open contexts returned by EnumerateContexts().
+	@param aInfo On completion, the context information.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iGetContextInfoIndex = aIndex;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotContextInfoIndex,iEtelPacketPtrHolder->iGetContextInfoIndex);
+	TPtr8& ptr2=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotContextInfo,aInfo);
+	Get(EPacketGetContextInfo,aStatus, ptr1, ptr2);
+	}
+EXPORT_C void RPacketService::GetNtwkRegStatus(TRequestStatus& aStatus, TRegistrationStatus& aRegistrationStatus) const
+// This function may be called by the client.
+/**
+	Retrieves the current registration status of the phone on the packet network.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketGetNtwkRegStatus) to cancel
+	a previously placed asynchronous GetNtwkRegStatus() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aRegistrationStatus On completion, the current registration status of
+	the	phone on the packet network.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetNtwkReg,aRegistrationStatus);
+	Get(EPacketGetNtwkRegStatus, aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyChangeOfNtwkRegStatus(TRequestStatus& aStatus,TRegistrationStatus& aRegistrationStatus) const
+// This asynchronous function may be called by the client.
+/**
+	Allows a client to be notified whenever a change in the status of the packet
+	network registration is detected.
+	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(EPacketNotifyChangeOfNtwkRegStatus)
+	to cancel a previously placed asynchronous NotifyChangeOfNtwkRegStatus() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aRegistrationStatus On completion, the new registration status of the
+	phone on the packet network.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotRegStatus,aRegistrationStatus);
+	Get(EPacketNotifyChangeOfNtwkRegStatus,aStatus,ptr1);
+	}
+EXPORT_C void RPacketService::GetMSClass(TRequestStatus& aStatus, TMSClass& aCurrentClass, TMSClass& aMaxClass) const
+/**
+	Gets both the current class and the highest class of the mobile phone.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketGetMSClass) to cancel a
+	previously placed asynchronous GetMSClass() request.
+	@param aStatus On completion, KErrNone if successful, or another of the system-wide error
+	codes.
+	@param aCurrentClass On completion, the current class of the phone.
+	@param aMaxClass On completion, the highest possible class the phone can emulate.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotCurrentMsClass,aCurrentClass);
+	TPtr8& ptr2=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotMaxMsClass,aMaxClass);
+	Get(EPacketGetMSClass, aStatus, ptr1, ptr2);
+	}
+EXPORT_C void RPacketService::SetMSClass(TRequestStatus& aStatus, TMSClass aClass) const
+/**
+	Sets the current packet class of the mobile station. This should never be higher
+	than the maximum packet class of the mobile station.
+	It is expected that this function will be used to force a ClassSuspensionRequired
+	mobile into a Class C mode of operation: either packet or circuit-switched only.
+	This is useful, for instance, in a situation where the user is billed for incoming
+	circuit-switched calls (a practice of U.S. network operators) and does not wish to
+	be available for incoming calls for long periods of time, but does want to keep the
+	packet side of the phone always on and always connected.
+	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(EPacketSetMSClass) to cancel a
+	previously placed asynchronous SetMSClass() request.
+	@param aStatus On completion, KErrNone if successful, orKErrTooBig if the
+	requested class is higher than the maximum class supported by the phone.
+	@param aClass The new packet class for the mobile station.
+@capability NetworkServices
+@capability WriteDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iMSClass = aClass;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotSetMsClass,iEtelPacketPtrHolder->iMSClass);
+	Set(EPacketSetMSClass, aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyMSClassChange(TRequestStatus& aStatus, TMSClass& aNewClass) const
+/**
+	Completes when there is a change in the current GPRS class of the mobile station.
+	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(EPacketNotifyMSClassChange) to
+	cancel a previously placed asynchronous NotifyMSClassChange() request.
+	@param aStatus On completion, KErrNone if successful, otherwise another of the system
+	wide error codes.
+	@param aNewClass On completion, the new packet class.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotNtfMsClass,aNewClass);
+	Get(EPacketNotifyMSClassChange, aStatus, ptr1);
+	}
+EXPORT_C TInt RPacketService::GetStaticCaps(TUint& aCaps, RPacketContext::TProtocolType aPdpType) const
+/**
+	Retrieves those capabilities of the TSY/phone that are static.
+	This is a synchronous function.
+	@param aCaps On return, a bitmask of the TStaticMiscCaps static capabilities.
+	@param aPdpType The static parameters may be different depending on the PdpType
+	supported on the phone. Hence the client must pass in the current PdpType
+	for which they wish to receive static capabilities.
+	@return KErrNone if successful, a system-wide error code if not.
+@capability None
+*/
+	{
+	TPckg<TUint> ptr1(aCaps);
+	TPckg<RPacketContext::TProtocolType> ptr2(aPdpType);
+	return Get(EPacketGetStaticCaps, ptr1, ptr2);
+	}
+EXPORT_C TInt RPacketService::GetDynamicCaps(TDynamicCapsFlags& aCaps) const
+/**
+	Retrieves those capabilities of the TSY/phone that are dynamic.
+	This is a synchronous function.
+	@param aCaps On return, a bitmask of the RPacketService::TDynamicCaps dynamic capabilities.
+	@return KErrNone if successful, a system-wide error code if not.
+@capability None
+*/
+	{
+	TPckg<TDynamicCapsFlags> ptr1(aCaps);
+	return Get(EPacketGetDynamicCaps, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyDynamicCapsChange(TRequestStatus& aStatus, TDynamicCapsFlags& aCaps) const
+/**
+	Completes when the dynamic packet data capabilities change.
+	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.
+	A common usage of the dynamic capabilities functions would be for GetDynamicCaps() to be
+	called first to retrieve the current set of capabilities, and then the NotifyDynamicCapsChange()
+	request to be posted to be kept informed of any changes.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketNotifyDynamicCapsChange)
+	to cancel a previously placed asynchronous NotifyDynamicCapsChange() request.
+	@param aStatus On completion, KErrNone if successful, a system-wide error
+	code if not.
+	@param aCaps On completion, a bitmask of the new RPacketService::TDynamicCaps dynamic capabilities.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotDynamicCaps,aCaps);
+	Get(EPacketNotifyDynamicCapsChange,aStatus,ptr1);
+	}
+EXPORT_C void RPacketService::SetPreferredBearer(TRequestStatus& aStatus, TPreferredBearer aBearer) const
+/**
+	Sets the preferred bearer for the Mobile Terminal to use when as default when
+	dropping from Class B operation to Class C. This could happen when the Mobile
+	Terminal moves into a Routing Area of cells or new GPRS network which operates
+	in Network Mode III. (Class C operation requires that the Mobile Terminal
+	is attached to either GSM or GPRS, not both.)
+	Should the Mobile Terminal be a Class C only device, this function is used
+	simply to switch bearers. If the required bearer is GSM, the Mobile Terminal
+	will immediately attempt to attach to the GSM service. If GPRS, the Mobile
+	Terminal may either immediately attempt to attach to the GPRS service or wait
+	until context activation to attach, depending on the current attach mode as
+	defined by TAttachMode.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketSetPrefBearer) to cancel
+	a previously placed asynchronous SetPreferredBearer() request.
+	@param aStatus On completion, KErrNone if successful, a system-wide error
+	code if not.
+	@param aBearer The new preferred bearer.
+@capability NetworkServices
+@capability WriteDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iPrefBearer = aBearer;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotSetPrefBearer,iEtelPacketPtrHolder->iPrefBearer);
+	Set(EPacketSetPrefBearer,aStatus, ptr1);
+	}
+EXPORT_C TInt RPacketService::GetPreferredBearer(TPreferredBearer& aBearer) const
+/**
+	Note that the synchronous variant of this method is deprecated. The asynchronous variant instead should be used.
+	Retrieves the currently selected preferred bearer to attach to when in Class C
+	operation. The TSY should cache this value, so the function should return quickly
+	hence there is no need for an asynchronous version.
+	@deprecated  The synchronous variant of this method is deprecated. The asynchronous variant instead should be used.
+	@param aBearer On return will contain the selected preferred bearer.
+	@return Result code. KErrNone if successful.
+@capability None
+*/
+	{
+	TPckg<TPreferredBearer> ptr1(aBearer);
+	return Get(EPacketGetPrefBearer, ptr1);
+	}
+EXPORT_C void RPacketService::GetPreferredBearer(TRequestStatus& aStatus, TPreferredBearer& aBearer) const
+/**
+	This asynchronous function retrieves the currently selected preferred bearer to attach to
+	when in Class C operation.
+	@param aStatus A reference to a TRequestStatus which on completion will contain the result code.
+	@param aBearer On completion will contain the selected preferred bearer.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetPrefBearer,aBearer);
+	Get(EPacketGetPrefBearer, aStatus, ptr1);
+	}
+EXPORT_C TInt RPacketService::SetAttachMode(TAttachMode aMode) const
+/**
+	Sets when the attachment to the GPRS network should occur, in version 1 of the API.
+	In either mode, the manual Attach() and Detach() functions will force the attach or detach
+	respectively, as long as it is a valid action.
+	@deprecated The asynchronous version should be used from v7.0S.
+	@param aMode The attach mode.
+	@return KErrNone if successful, a system-wide error code if not.
+@capability WriteDeviceData
+*/
+	{
+	TPckg<TAttachMode> ptr1(aMode);
+	return Set(EPacketSetAttachMode, ptr1);
+	}
+EXPORT_C void RPacketService::SetAttachMode(TRequestStatus& aStatus, TAttachMode aMode) const
+/**
+	This asynchronous method may be called by the client. It has superseded the synchronous
+	variant of this method.
+	It sets when the 'attach' to the packet network should occur.
+	@param aStatus A reference to a TRequestStatus.
+	@param aMode This parameter contains instructions for this method: RPacketService::EAttachWhenPossible
+	and RPacketService::EAttachWhenNeeded.
+@capability WriteDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iAttachMode = aMode;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotSetAttachMode,iEtelPacketPtrHolder->iAttachMode);
+	Set(EPacketSetAttachMode, aStatus, ptr1);
+	}
+EXPORT_C TInt RPacketService::GetAttachMode(TAttachMode& aMode) const
+/**
+	Retrieves the current mode of GPRS Attach mode, in version 1 of the API.
+	@deprecated The asynchronous version should be used from v7.0S.
+	@param aMode On return, the current attachment mode.
+	@return KErrNone if successful, a system-wide error code if not.
+@capability None
+*/
+	{
+	TPckg<TAttachMode> ptr1(aMode);
+	return Get(EPacketGetAttachMode, ptr1);
+	}
+EXPORT_C void RPacketService::GetAttachMode(TRequestStatus& aStatus, TAttachMode& aMode) const
+/**
+	This asynchronous method may be called by the client. It has superseded the synchronous
+	variant of this method.
+	It will retrieve the current mode of the packet network attach operation.
+	@param aStatus This is a reference to aTRequestStatus.
+	@param aMode Has 2 values: RPacketService::EAttachWhenPossible and RPacketService::EAttachWhenNeeded.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1 = iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetAttachMode, aMode);
+	Get(EPacketGetAttachMode, aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyAttachModeChange(TRequestStatus& aStatus, TAttachMode& aMode) const
+/**
+	Notifies the client when there is a change in the current mode of the packet network attach operation.
+	@param aStatus This is a reference to a TRequestStatus.
+	@param aMode Has 2 values: RPacketService::EAttachWhenPossible and RPacketService::EAttachWhenNeeded.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1 = iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotNotifyAttachModeChange, aMode);
+	Get(EPacketNotifyAttachModeChange, aStatus, ptr1);
+	}
+EXPORT_C TInt RPacketService::SetDefaultContextParams(const TDesC8& aPckg) const
+//This function may be called by the client.
+/**
+	Sets the default context parameters in the phone, in version 1 of the API.
+	The default context parameters are the parameters which the phone will use if no
+	context parameters have been explicitly set up via either the ETel API or AT
+	commands from an external PC.
+	The actual context parameters are set up in the RPacketContext::TContextConfigGPRS
+	or RPacketContext::TContextConfigCDMA structure.
+	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 KConfigGPRS, KConfigCDMA or KConfigRel99Rel4. The TSY will then
+	cast the descriptor to the correct TPacketDataConfigBase-derived class.
+	@deprecated The asynchronous version should be used from v7.0S.
+	@param aPckg A TContextConfigXXX context configuration class packaged as a
+	TPckg<TContextConfigXXX>.
+	@return KErrNone if successful, or a system-wide error code if not.
+@capability WriteDeviceData
+*/
+	{
+	return Set(EPacketSetDefaultContextParams, aPckg);
+	}
+EXPORT_C void RPacketService::SetDefaultContextParams(TRequestStatus& aStatus, const TDesC8& aPckg) const
+/**
+	This asynchronous method may be called by the client. It has superseded the synchronous
+	variant of this method.
+	It will set the default context parameters in the ME. These are the parameters the ME will
+	use if no explicit context parameters have previously been set up.
+	@param aStatus A reference to a TRequestStatus.
+	@param aPckg A TContextConfigGPRS or TContextConfigCDMA context configuration class packaged
+	inside a TPckg<TContextConfigGPRS> or TPckg<TContextConfigCDMA> class.
+	To determine how to correctly unpack the descriptor inside the TSY, the TSY must first cast
+	The descriptor to a TPacketDataConfigBase pointer and check the iExtensionId.
+	Depending on the iExtensionId, the TSY will then cast the descriptor to the correct
+	TPacketDataConfigBase-derived class.
+@capability WriteDeviceData
+*/
+	{
+	Set(EPacketSetDefaultContextParams, aStatus, aPckg);
+	}
+EXPORT_C TInt RPacketService::GetDefaultContextParams(TDes8& aPckg) const
+/**
+	Retrieves the default context parameters that are stored in the phone, in version 1 of the API.
+	@deprecated The asynchronous version should be used from v7.0S.
+	@param aPckg On return, a RPacketContext::TContextConfigGPRS or RPacketContext::TContextConfigCDMA
+	context configuration class packaged inside a TPckg<TContextConfigGPRS> or
+	TPckg<TContextConfigCDMA> class. 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 KConfigGPRS, KConfigCDMA or KConfigRel99Rel4.
+	@return KErrNone if successful, or a system-wide error code if not.
+@capability ReadDeviceData
+*/
+	{
+	return Get(EPacketGetDefaultContextParams, aPckg);
+	}
+EXPORT_C void RPacketService::GetDefaultContextParams(TRequestStatus& aStatus, TDes8& aPckg) const
+/**
+	This asynchronous method may be called by the client. It has superseded the synchronous
+	variant of this method.
+	It will retrieve the default context parameters that are stored in the ME.
+	@param aStatus This is a reference to a TRequestStatus.
+	@param aPckg On completion contains the packaged default context parameters. aPckg should be
+	a TPckg of a TPacketDataConfigBase derived class.
+	@see RPacketContext::TContextConfigCDMA
+	@see RPacketContext::TContextConfigGPRS
+	@see RPacketContext::TContextConfigR99_R4
+	@see RPacketContext::TContextConfig_R5
+@capability ReadDeviceData
+*/
+	{
+	Get(EPacketGetDefaultContextParams, aStatus, aPckg);
+	}
+EXPORT_C void RPacketService::GetCurrentReleaseMode(TRequestStatus& aStatus, TPacketReleaseMode& aReleaseMode) const
+/**
+	This asynchronous method may be called by the client application.
+	It returns the current packet network release mode(Release97/98, Release 99 or Release 4).
+	@param aStatus This is a reference to a TRequestStatus.
+	@param aNetworkMode On completion contains the retrieved release mode.
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1 = iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetCurrentReleaseMode, aReleaseMode);
+	Get(EPacketGetCurrentReleaseMode, aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::NotifyReleaseModeChange(TRequestStatus& aStatus, TPacketReleaseMode& aReleaseMode) const
+/**
+	This asynchronous notification function may be called by the client.
+	It completes if the packet release mode of the network changes.
+	@param aStatus This is a reference to a TRequestStatus.
+	@param aReleaseMode This will contain the new mode (Release97/98, Release 99 or Release 4)
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotNotifyModeChange, aReleaseMode);
+	Get(EPacketNotifyReleaseModeChange,aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::EnumerateNifs(TRequestStatus& aStatus, TInt& aCount) const
+/**
+	This asynchronous method may be called by the client application.
+	It returns the number of defined packet network interfaces in the parameter aCount.
+	One network interface (NIF) exists per local IP address, but there may be several PDP contexts
+	per NIF, i.e. one primary and several secondary contexts, all sharing the IP address and other
+	configuration information such as PDP type and APN.
+	@param aCount Number of defined packet network interfaces
+@capability None
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateNifs,aCount);
+	Get(EPacketEnumerateNifs, aStatus, ptr1);
+	}
+EXPORT_C void RPacketService::GetNifInfo(TRequestStatus& aStatus, TInt aIndex, TDes8& aNifInfoV2) const
+/**
+	This asynchronous method may be called by the client application.
+	It retrieves information about the network interface specified by the aIndex parameter.
+	It is usual to use this function in conjunction with the EnumerateNifs() method, which
+	returns the current number of defined packet Network interfaces in its 'aCount' argument.
+	@param aStatus TRequestStatus reference, enables asynchronous function call
+	@param aIndex Specifies network interface for which information is to be retrieved.
+	The valid range for aIndex will be between 0 and (n-1) where n is the number returned in
+	aCount. If an invalid index is specified the method will return KErrArgument in its aStatus.
+	@param aNifInfoV2 Reference to a TNifInfoV2 class packaged inside a TPckg<> class. Contains the
+	returned Network Interface information
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iGetNifInfoIndex = aIndex;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetNifInfo,iEtelPacketPtrHolder->iGetNifInfoIndex);
+	Get(EPacketGetNifInfo,aStatus, ptr1, aNifInfoV2);
+	}
+EXPORT_C void RPacketService::EnumerateContextsInNif(TRequestStatus& aStatus, const TDesC& aExistingContextName, TInt& aCount) const
+/**
+	This asynchronous method may be called by the client application.
+	It retrieves the number of contexts sharing a particular network interface, including the
+	primary context (if it still exists) and the context specified in aExistingContextName.
+	@param aStatus TRequestStatus reference, enables asynchronous function call
+	@param aExistingContextName The name of any context belonging to the network interface (NIF)
+	@param aCount Contains the number of contexts sharing a NIF.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateContextsInNif,aCount);
+	SetAndGet(EPacketEnumerateContextsInNif, aStatus, ptr1, aExistingContextName);
+	}
+EXPORT_C void RPacketService::GetContextNameInNif(TRequestStatus& aStatus, const TDesC& aExistingContextName, TInt aIndex, TDes& aContextName) const
+/**
+	This asynchronous method may be called by the client application.
+	It retrieves the name of the context specified by aIndex for a particular network interface,
+	which is determined by aExistingContextName
+	@param aStatus TRequestStatus reference, enables asynchronous function call
+	@param aExistingContextName The name of any context belonging to the network interface (NIF)
+	@param aIndex Integer between 0 and (n-1) where n is the number of existing contexts
+	sharing this network interface (as provided by EnumerateContextsInNif() method).
+	@param aContextName The name of the context specified by aIndex is returned in this parameter.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iGetContextNameInNif.iIndex=aIndex;
+	iEtelPacketPtrHolder->iGetContextNameInNif.iExistingContextName=aExistingContextName;
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetContextNameInNif,iEtelPacketPtrHolder->iGetContextNameInNif);
+	Get(EPacketGetContextNameInNif, aStatus, ptr1, aContextName);
+	}
+TInt RPacketService::PrepareOpenSecondary(const TDesC& aOriginalContextName)
+/**
+	This is an internal API method. It is not intended for direct client access.
+	It is called from RPacketContext::OpenNewSecondaryContext().
+	It passes the name of the context (which is to spawn a secondary context) to the TSY.
+	This alerts the TSY to the fact that the next context creation call is going to be
+	for a secondary context.
+	@param aOriginalContextName Name of the original context that this secondary context is
+	spawned from.
+	@return KErrNone if successful, KErrNotSupported if the TSY does not support
+	secondary contexts.
+*/
+	{
+	__ASSERT_ALWAYS(aOriginalContextName.Length()!=0,PanicClient(KErrBadName));
+	return Set(EPacketPrepareOpenSecondary, aOriginalContextName);
+	}
+EXPORT_C RPacketService::TNifInfoV2::TNifInfoV2()
+: TPacketBase(), iContextName(NULL), iNumberOfContexts(0), iNifStatus(RPacketContext::EStatusUnknown),
+iPdpAddress(NULL), iContextType(RPacketService::EUnspecified)
+/**
+	Constructor for TNifInfoV2 class
+	This class contains network information (NIF) parameters.
+	The member data are initialized to zero, NULL, or unknown. The client should set the
+	parameters to valid values.
+*/
+	{
+	iExtensionId = KETelExtPcktV2;
+	};
+EXPORT_C void RPacketService::DeactivateNIF(TRequestStatus& aStatus, const TDesC& aContextName) const
+/**
+	This asynchronous method may be called by the client application.
+	Invokes a packet network deactivation of all associated contexts sharing the same network interaface (NIF)
+	with the specified context (aContextName argument) using the tear down indication when requesting the deactivation
+	operation for the specified context.
+	@param aStatus TRequestStatus reference, enables asynchronous function call.
+	@param aContextName Name of Context to be deactivated.
+@capability NetworkServices
+*/
+	{
+	Set(EPacketDeactivateNIF, aStatus, aContextName);
+	}
+TPacketType::TPacketType()
+	{}
+EXPORT_C TInt TPacketType::ExtensionId() const
+/**
+* This method returns the packet API extension number of the class
+*
+* @return TInt An integer that will indicate the version of the type
+* @capability None
+*/
+	{
+	return iExtensionId;
+	}
+void TPacketType::InternalizeL(RReadStream& aStream)
+/**
+* This method internalizes the packet type from a stream
+*
+* @param aStream The read stream containing the packet type
+*/
+	{
+	iExtensionId=aStream.ReadInt32L();
+	}
+void TPacketType::ExternalizeL(RWriteStream& aStream) const
+/**
+* This method externalizes the packet type into a stream
+*
+* @param aStream The write stream that will contain the packet type
+*/
+	{
+	aStream.WriteInt32L(iExtensionId);
+	}
+EXPORT_C RPacketService::TMbmsServiceAvailabilityV1::TMbmsServiceAvailabilityV1()
+	{
+	iExtensionId=KETelExtPcktV1;
+	}
+void RPacketService::TMbmsServiceAvailabilityV1::InternalizeL(RReadStream& aStream)
+/**
+* This method internalizes the MBMS Service availability parameters from a stream
+*
+* @param aStream The read stream containing the MBMS Service availability parameters
+*/
+	{
+	TPacketType::InternalizeL(aStream);
+	iTmgi.SetServiceId(STATIC_CAST(TUint,aStream.ReadUint32L()));
+	iTmgi.SetMCC(STATIC_CAST(TUint16,aStream.ReadUint32L()));
+	iTmgi.SetMNC(STATIC_CAST(TUint16,aStream.ReadUint32L()));
+	iMbmsServiceMode = STATIC_CAST(TMbmsServiceMode,aStream.ReadUint32L());
+	iMbmsAvailabilityStatus = STATIC_CAST(TMbmsAvailabilityStatus,aStream.ReadUint32L());
+	iMbmsAccessBearer = STATIC_CAST(TMbmsScope,aStream.ReadUint32L());
+	}
+void RPacketService::TMbmsServiceAvailabilityV1::ExternalizeL(RWriteStream& aStream) const
+/**
+* This method externalizes the MBMS Service availability parameters into a stream
+*
+* @param aStream The write stream that will contain the MBMS Service availability parameters
+*/
+	{
+	TPacketType::ExternalizeL(aStream);
+	aStream.WriteInt32L(iTmgi.GetServiceId());
+	aStream.WriteInt32L(iTmgi.GetMCC());
+	aStream.WriteInt32L(iTmgi.GetMNC());
+	aStream.WriteInt32L(iMbmsServiceMode);
+	aStream.WriteInt32L(iMbmsAvailabilityStatus);
+	aStream.WriteInt32L(iMbmsAccessBearer);
+	}
+EXPORT_C void RPacketService::NotifyMbmsServiceAvailabilityChange(TRequestStatus& aStatus) const
+/**
+	Notifies the client that changes have been made to the MBMS Service availability list.
+	When it completes, it does not return the new version of the list so the client will have to
+	retrieve the list again if interested in the new list.
+	@param aReqStatus returns the result code after the asynchronous call completes.
+@capability None
+*/
+	{
+	Blank(EPacketNotifyMbmsServiceAvailabilityChange,aStatus);
+	}
+EXPORT_C void RPacketService::UpdateMbmsMonitorServiceListL(TRequestStatus& aStatus,const TMbmsAction aAction, CPcktMbmsMonitoredServiceList* aLists) const
+/**
+	Updates the MBMS monitor service availability list with the entries as per the action mentioned in second parameter.
+	The list, which is supplied by the client in an instance of CRetrievePcktMbmsServiceAvailability, should not
+	contain more entries than can be stored.
+	This method will store all the mbms service availability list entries in the CPcktMbmsMonitoredServiceList
+	into the packet storage.
+	@param aReqStatus returns the result code after the asynchronous call completes.
+			Completes with KErrNotFound, if all the supplied entries are invalid for removal.
+			Completes with KErrMbmsImpreciseServiceEntries, if some of the valid entries cannot be removed.
+	@param aAction Holds the MBMS action(add, remove or remove all).
+	@param aLists List of Mbms service availability to be stored phone-side.
+@capability WriteDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	delete iEtelPacketPtrHolder->iStoreMbmsBuf;
+	iEtelPacketPtrHolder->iStoreMbmsBuf = NULL;
+	if(aAction == ERemoveAllEntries)
+		{
+		iEtelPacketPtrHolder->iMbmsAction = aAction;
+		TPtrC8& ptr1=iEtelPacketPtrHolder->SetC(CEtelPacketPtrHolder::ESlotUpdateMbmsMonitorServiceListL,iEtelPacketPtrHolder->iMbmsAction);
+		Set(EPacketUpdateMbmsMonitorServiceList,aStatus,ptr1);
+		}
+	else
+		{
+		__ASSERT_ALWAYS(aLists!=NULL,PanicClient(EEtelPanicNullHandle));
+		iEtelPacketPtrHolder->iStoreMbmsBuf=aLists->StoreLC();
+		CleanupStack::Pop();
+		iEtelPacketPtrHolder->iMbmsAction = aAction;
+		TPtrC8& ptr1=iEtelPacketPtrHolder->SetC(CEtelPacketPtrHolder::ESlotUpdateMbmsMonitorServiceListL,iEtelPacketPtrHolder->iMbmsAction);
+		(iEtelPacketPtrHolder->iStoreMbmsPtr).Set((iEtelPacketPtrHolder->iStoreMbmsBuf)->Ptr(0));
+		Set(EPacketUpdateMbmsMonitorServiceList,aStatus,ptr1,iEtelPacketPtrHolder->iStoreMbmsPtr);
+		}
+	}
+EXPORT_C void RPacketService::NotifyMbmsNetworkServiceStatusChange(TRequestStatus& aStatus, TMbmsNetworkServiceStatus& aServiceStatus) const
+/**
+	Allows a client to be notified whenever a change in the MBMS network service status identified.
+	There can be 3 states that MBMS feature availability could return,
+	Unknown - when UE is not GMM Attached.
+	Supported - When UE is GMM Attached and it is known that cell supports MBMS.
+	Not Supported - When UE is GMM Attached and it is known that cell does not support MBMS.
+	This is an asynchronous function.
+	Once the notification completes, the client must re-post the notification
+	if the client wish to continue receiving further notifications.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketNotifyMbmsNetworkServiceStatusChange)
+	to cancel a previously placed asynchronous NotifyMbmsNetworkServiceStatusChange() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aServiceStatus On completion, the current mbms network service status of
+	the	phone.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotNotifyMbmsNetworkServiceStatusChange,aServiceStatus);
+	Get(EPacketNotifyMbmsNetworkServiceStatusChange,aStatus,ptr1);
+	}
+EXPORT_C void RPacketService::GetMbmsNetworkServiceStatus(TRequestStatus& aStatus,TBool aAttemptAttach, TMbmsNetworkServiceStatus& aServiceStatus) const
+/**
+	Retrieves the MBMS network status of the phone. The indication of cell support for MBMS feature
+	is only known from GMM Attach response from network or during Routing Area update.
+	A consequence of this is that it is required for the UE to be in GMM Attach mode in order
+	for either of these messages to be received.
+	If the UE is not in GMM ATTACH then it is unable to determine MBMS network support.
+	There can be 3 states that MBMS feature availability could return,
+	Unknown - when UE is not GMM Attached.
+	Supported - When UE is GMM Attached and it is known that cell supports MBMS.
+	Not Supported - When UE is GMM Attached and it is know that cell does not support MBMS.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketGetMbmsNetworkServiceStatus) to cancel
+	a previously placed asynchronous GetMbmsNetworkServiceStatus() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aAttemptAttach On completion, the MBMS attach information,if it is true
+	then GMM attached is perfomed, else any of the states is returned.
+	@param aServiceStatus On completion, the current mbms network service status of
+	the	phone.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketPtrHolder->iMbmsAttemptAttach = aAttemptAttach;
+	TPtr8& ptr1 = iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetMbmsNetworkServiceStatus, iEtelPacketPtrHolder->iMbmsAttemptAttach);
+	TPtr8& ptr2 = iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotGetMbmsNetworkServiceStatus2, aServiceStatus);
+	Get(EPacketGetMbmsNetworkServiceStatus, aStatus, ptr1,ptr2);
+	}
+EXPORT_C void RPacketService::EnumerateMbmsMonitorServiceList(TRequestStatus& aStatus, TInt& aCount, TInt& aMaxAllowed) const
+/**
+	Retrieves both, the number of services in the Mbms Monitor service list in the TSY, and
+	the maximum possible number of Mbms Monitor services.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketEnumerateMbmsMonitorServiceList) to cancel
+	a previously placed asynchronous EnumerateMbmsMonitorServiceList() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aCount On completion, the number of Mbms Monitor services existing in the TSY.
+	@param aMaxAllowed On completion, the maximum number of Mbms Monitor services that
+	are allowed in the TSY.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateMbmsMonitorCount,aCount);
+	TPtr8& ptr2=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateMbmsMonitorMaxCount,aMaxAllowed);
+	Get(EPacketEnumerateMbmsMonitorServiceList, aStatus, ptr1, ptr2);
+	}
+EXPORT_C void RPacketService::EnumerateMbmsActiveServiceList(TRequestStatus& aStatus, TInt& aCount, TInt& aMaxAllowed) const
+/**
+	Retrieves both, the number of services in the Mbms Active service list in the TSY, and
+	the maximum possible number of Mbms Active services.
+	This is an asynchronous function.
+	Use RTelSubSessionBase::CancelAsyncRequest(EPacketEnumerateMbmsActiveServiceList) to cancel
+	a previously placed asynchronous EnumerateMbmsActiveServiceList() request.
+	@param aStatus On completion, KErrNone if successful, or a system-wide error
+	code if not successful.
+	@param aCount On completion, the number of Mbms Active services existing in the TSY.
+	@param aMaxAllowed On completion, the maximum number of Mbms Active services that
+	are allowed in the TSY.
+@capability ReadDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	TPtr8& ptr1=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateMbmsActiveCount,aCount);
+	TPtr8& ptr2=iEtelPacketPtrHolder->Set(CEtelPacketPtrHolder::ESlotEnumerateMbmsActiveMaxCount,aMaxAllowed);
+	Get(EPacketEnumerateMbmsActiveServiceList, aStatus, ptr1, ptr2);
+	}
+/***********************************************************************************/
+//
+// RPacketMbmsContext
+//
+/***********************************************************************************/
+EXPORT_C RPacketMbmsContext::RPacketMbmsContext()
+/**
+	Standard constructor.
+*/
+	{
+	}
+EXPORT_C RPacketMbmsContext::TContextConfigMbmsV1::TContextConfigMbmsV1()
+: TPacketDataConfigBase()
+/**
+	Standard constructor. Sets the member data values to the defaults.
+	This class contains member data compatible with parameters required for configuring a
+	MBMS Broadcast context.
+	The iExtensionId parameter, set automatically by ETel, is used by the TSY when unpacking this
+	class from a TPckg<> to indicate it is to be unpacked as a TContextConfigMbmsV1 class.
+*/
+	{
+	iExtensionId = KConfigMBMS;
+	};
+EXPORT_C TInt RPacketMbmsContext::OpenNewContext(RPacketService& aPacketNetwork,TDes& aContextName)
+/**
+	Creates a MBMS context (i.e. RPacketMbmsContext) on an existing RPacketService
+	connection.
+	The TSY will return KErrUmtsMaxNumOfContextExceededByPhone if the number of MBMS contexts
+	supported by the phone is exceeded. The TSY will return KErrUmtsMaxNumOfContextExceededByNetwork
+	if the number of MBMS contexts supported by the network is exceeded.
+	An opened RPacketMbmsContext must be closed explicitly by calling Close() to
+	prevent a resource (memory) leak.
+	@param aPacketNetwork An RPacketMbmsContext 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 Set as the hint for the TSY to identify the Mbms 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);
+	aContextName = KMBMSContextName; //set this as the hint for the TSY to use to create correct(MBMS) object
+	TIpcArgs args(&name,&aContextName,subSessionHandle);
+	ret= CreateSubSession(*session,EEtelOpenFromSubSession,args);
+	if (ret)
+		{
+		Destruct();
+		}
+	return ret;
+	}
+EXPORT_C void RPacketMbmsContext::UpdateMbmsSessionList(TRequestStatus& aStatus,const TMbmsAction aAction, const TMbmsSessionId aSessionId) const
+/**
+	Provides MBMS client the facility to add a new session to be received or remove
+	an existing session to/from the mbms services table.
+	@param aStatus On completion, KErrNone if successful.
+			Completes with KErrNotFound, if the supplied session is invalid for removal.
+			In the above case the action would be ERemoveEntries.
+			Completes with KErrMbmsImpreciseServiceEntries, if some of the valid sessions cannot be removed.
+			In the above case the action would be ERemoveAllEntries.
+			Or a system-wide error code if not successful.
+	@param aAction The session action information which can be either add,remove or removeall.
+	@param aSessionId The MBMS session identifier which need to be received or removed.
+@capability WriteDeviceData
+*/
+	{
+	__ASSERT_ALWAYS(iEtelPacketContextPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
+	iEtelPacketContextPtrHolder->iMbmsAction = aAction;
+	TPtrC8& ptr1=iEtelPacketContextPtrHolder->SetC(CEtelPacketPtrHolder::ESlotUpdateMbmsSessionList,iEtelPacketContextPtrHolder->iMbmsAction);
+	iEtelPacketContextPtrHolder->iSessionId = aSessionId;
+	TPtrC8& ptr2=iEtelPacketContextPtrHolder->SetC(CEtelPacketPtrHolder::ESlotUpdateMbmsSessionList2,iEtelPacketContextPtrHolder->iSessionId);
+	Set(EPacketContextUpdateMbmsSessionList, aStatus, ptr1,ptr2);
+	}
+EXPORT_C void RPacketMbmsContext::Close()
+/**
+	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.
+	An opened RPacketMbmsContext must be closed explicitly by calling Close() to
+	prevent a resource (memory) leak.
+@capability None
+*/
+	{
+	CloseSubSession(EEtelClose);
+	Destruct();
+	}
+EXPORT_C RPacketMbmsContext::CMbmsSession* RPacketMbmsContext::CMbmsSession::NewL()
+/**
+* Creates an instance of CMbmsSession
+*/
+	{
+	CMbmsSession *self = new(ELeave)CMbmsSession;
+	return self;
+	}
+EXPORT_C void RPacketMbmsContext::CMbmsSession::InternalizeL(const TDesC8& aBuffer)
+/**
+* This method internalizes the CMbmsSession from the aBuffer.
+* @param	aBuffer	Holds the streamed data of CMbmsSession type.
+*/
+	{
+	iSessionIdList.Reset();
+	TUint uintLen=sizeof(TUint);
+	TInt cursor=0;
+	if(aBuffer.Length() < cursor + uintLen)
+		User::Leave(KErrOverflow);
+	Mem::Copy(&iExtensionId,aBuffer.Ptr(),uintLen);
+	cursor+=uintLen;
+	if(aBuffer.Length() < cursor + uintLen)
+		User::Leave(KErrOverflow);
+	TUint count(0);
+	Mem::Copy(&count,aBuffer.Ptr()+cursor,uintLen);
+	cursor+=uintLen;
+	TUint session=0;
+	for(TUint i=0;i<count;i++)
+		{
+		if(aBuffer.Length() < cursor + uintLen)
+			User::Leave(KErrOverflow);
+		Mem::Copy(&session,aBuffer.Ptr()+cursor,uintLen);
+		cursor+=uintLen;
+		iSessionIdList.Append(session);
+		}
+	}
+EXPORT_C void RPacketMbmsContext::CMbmsSession::ExternalizeL(HBufC8*& aBuffer)
+/**
+* This method externalizes the CMbmsSession into the aBuffer.
+* @param	aBuffer	Holds the streamed data of CMbmsSession type.
+*/
+	{
+	TUint uintLen=sizeof(TUint);
+	TUint size = uintLen; //ExtensionId
+	TUint count=iSessionIdList.Count();
+	size += uintLen; //Number of iSessionIdList elements
+	size += count*(uintLen);
+	if(aBuffer)
+		{
+	 	delete aBuffer;
+	 	aBuffer=NULL;
+	 	}
+	aBuffer=HBufC8::NewL(size);
+	aBuffer->Des().SetLength(size);
+	TInt cursor(0);
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),(const TUint8*)(&iExtensionId),uintLen);
+	cursor+=uintLen;
+	Mem::Copy(const_cast<TUint8*>(aBuffer->Des().Ptr()+cursor),(const TUint8* )(&count),uintLen);
+	cursor+=uintLen;
+	for(TUint i=0;i<count;i++)
+		{
+		Mem::Copy((TUint8*)(aBuffer->Des().Ptr()+cursor),(const TUint8* )(&iSessionIdList[i]),uintLen);
+		cursor+=uintLen;
+		}
+	}
+EXPORT_C TUint RPacketMbmsContext::CMbmsSession::ExtensionId() const
+/**
+* Returns the value of iExtensionId for the associated class.
+* e.g. iExtensionId=KETelExtPcktV1 for all the V1 classes.
+*
+* @return The protected data member iExtensionId, which specifies the API version number.
+*/
+	{
+	return iExtensionId;
+	}
+RPacketMbmsContext::CMbmsSession::CMbmsSession()
+/**
+* Standard constructor.
+*/
+	{
+	iExtensionId = KETelExtPcktV1;
+	}
+EXPORT_C RPacketMbmsContext::CMbmsSession::~CMbmsSession()
+/**
+* Standard destructor
+*/
+	{
+	iSessionIdList.Reset();
+	iSessionIdList.Close();
+	}

changeset 0	3553901f7fa8
child 24	6638e7f4bd8f