--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelpacketdata/cetel/etelpckt.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,2902 @@
+// 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();
+ }
+