// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Multimode Packet Data API

// GPRS, CDMAOne, CDMA2000

// 

//

#include "Et_clsvr.h"

#include "ETELEXT.H"

// Packet header files

#include "pcktptr.h"

#include "pcktcs.h"

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

_LIT(KETelNewContextName, "::");

/*GLDEF_C TInt E32Dll(TDllReason)

//

// DLL entry point

//

	{

	return KErrNone;

	}

*/

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

//

// RPacketContext

//

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

EXPORT_C RPacketContext::RPacketContext()

	:iEtelPacketContextPtrHolder(NULL)

	{

	}

EXPORT_C void RPacketContext::ConstructL()

/**

 * This function creates an instance of CPacketContextPtrHolder & assigns the iEtelPacketContextPtrHolder

 * pointer to it. 

 */

	{

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

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

	}

EXPORT_C void RPacketContext::Destruct()

/**

 * This function deletes & 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.

 * It creates a new 'context' (ie: RPacketContext)

 *

 * @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 & pass this name back to the client

 * using this parameter. The client can use this name to uniquely identify the particular context.

 */

	{

	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

	TIpcArgs args;

	args.Set(0,&name);

	args.Set(1,&aContextName);

	args.Set(2,subSessionHandle);

	SetSessionHandle(*session);

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

	if (ret)

		Destruct();

	return ret;

	}

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

/**

 * This function may be called by the client application.

 * It opens a handle on an existing RPacketContext object identified by a name. KErrNotFound is returned if the object does 

 * not exist

 *

 * @param aPacketNetwork : This identifies to which 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 the RPacketContext::OpenNewContext() method.

 */

	{

	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));

	TIpcArgs args;

	args.Set(0,REINTERPRET_CAST(TAny*,CONST_CAST(TDesC*,&aContextName)));

	args.Set(1,TIpcArgs::ENothing);

	args.Set(2,REINTERPRET_CAST(TAny*,subSessionHandle));

	SetSessionHandle(*session);

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

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C void RPacketContext::Close()

/**

 * This function may be called by the client application.

 * 

 * It 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.

 */

	{

	CloseSubSession(EEtelClose);

	Destruct();

	}

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

/**

 * This function may be called by the client application.

 * 

 * It passes to the TSY all parameters necessary to configure the particular context.

 * It is an asynchronous function.

 *

 * @param aStatus : a reference to a TRequestStatus, enabling the client to make this function call

 * asynchronously. 

 *

 * @param aConfig : this is a reference to a TContextConfigGPRS or TContextConfigCDMA class packaged

 * inside a TPckg<> class. The TContextConfigGPRS/CDMA classes contain all the necessary parameters

 * required to configure a context on a GPRS/CDMA network. In the case of this function call, the value

 * for each parameter will be input by the client and probably obtained from CommDB. 

 */

	{

	Set(EPacketContextSetConfig, aStatus, aConfig);

	}

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

/**

 * This function may be called by the client application.

 *

 * It requests the configuration of the current context.

 * It is an asynchronous function.

 *

 * @param aStatus : this is a reference to a TRequestStatus.

 *

 * @param aConfig : this is a reference to a TContextConfigGPRS or TContextConfigCDMA class packaged

 * inside a TPckg<> class. The TContextConfigGPRS/CDMA classes contain all the necessary parameters

 * required to configure a context on a GPRS/CDMA network. In the case of this function call, the value

 * for each parameter will be input by the TSY.

 */

	{

	Get(EPacketContextGetConfig, aStatus, aConfig);

	}

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

/**

 * This function may be called by the client application.

 * 

 * It notifies a client whenever a change in the current context is detected and passes back the

 * updated configuration. 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.

 *

 * @param aStatus : this is a reference to a TRequestStatus.

 *

 * @param aConfig : this is a reference to a TContextConfigGPRS or TContextConfigCDMA class packaged

 * inside a TPckg<> class. The TContextConfigGPRS/CDMA classes contain all the necessary parameters

 * required to configure a context on a GPRS/CDMA network. In the case of this function call, the value

 * for each parameter will be input by the TSY.

 */

	{

	Get(EPacketContextNotifyConfigChanged, aStatus, aConfig);

	}

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

/**

 * This function may be called by the client application.

 *

 * It activates a context that has been previously configured using the RPacketContext::SetConfig() method.

 * Once this function completes, the context will remain in an 'Activating' state until PPP has been successfully

 * negotiated between the phone & the packet network gateway. Once PPP is negotiated, the context

 * can be considered to be 'Activated'.

 *

 * It is an asynchronous function.

 *

 * @param aStatus : this is a reference to a TRequestStatus.

 */

	{

	Blank(EPacketContextActivate,aStatus);

	}

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

/**

 * This function may be called by the client application.

 *

 * It deactivates a context previously configured on the phone. 

 *

 * It is an asynchronous function.

 *

 * @param aStatus : this is a reference to a TRequestStatus.

 */

	{

	Blank(EPacketContextDeactivate, aStatus);

	}

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

/**

 * This function may be called by the client application.

 *

 * It deletes a context previously configured on the phone. Note that although the context is deleted

 * from the TSY (and/or ME), the client's RPacketContext subsession remains. To remove this, a client

 * must call RPacketContext::Close().

 *

 * It is an asynchronous function.

 *

 * @param aStatus : this is a reference to a TRequestStatus.

 */

	{

	Blank(EPacketContextDelete, aStatus);

	}

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

/**

 * This function may be called by the client application.

 *

 * It provides a client with details of the comm port to be used for sending/receiving user data. 

 * This comm port is used by Network Interfaces, NIFs, (for example: PPP.NIF) to send & receive data.

 * In a 2-box device this port would generally be the same as that used by the TSY to setup/control the connection.

 * In a 1-box device this port would generally be different to the port used by the TSY to setup/control the connection.

 * It is an asynchronous function.

 *

 * @param aStatus : this is a reference to a TRequestStatus. 

 * @param aDataPort : this is a reference to a TCommPort class containing information on the port, including

 * its name and the associated CSY used to access it.

 */

	{

	__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

/**

 * This function may be called by the client application.

 * It is an asynchronous function.

 *

 * It allows a client, who previously called RPacketContext::LoanCommPort, to inform ETel & hence the 

 * TSY that it has finished with the comm port.

 *

 * @param aStatus : this is a reference to a TRequestStatus. 

 */

	{

	Blank(EPacketContextRecoverCommPort, aStatus);

	}

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

/**

 * This function may be called by the client application.

 * It is a synchronous function.

 *

 * It allows a client to get the current status of the context, as defined by the enum TContextStatus.

 *

 * @param aContextStatus : a reference to a enum value defined by TContextStatus.  

 */

	{

	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.

 * It is an asynchronous function.

 *

 * It allows a client to receive a notification whenever a change in the status of the context is detected.

 * The new status is also passed back to the client. It should be noted that once the notification completes, 

 * the client must then re-post the notification if they wish to continue receiving further status change notifications.

 * 

 * @param aStatus : this is reference to a TRequestStatus.

 * @param aContextStatus : this is a reference to the new enum value defined by TContextStatus.

 */

	{

	__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

/**

 * This function may be called by the client application.

 * It is an asynchronous function.

 *

 * It allows a client to retrieve the name of the QoS profile (RPacketQoS) associated with the

 * context (RPacketContext). If no QoS profile has been defined by the client, the name returned 

 * will be be NULL

 *

 * @param aQoSProfile : this is a reference to the name of the existing qos profile. If no profile

 * has been defined then this name will be NULL.

 */

	{

	TPckg<TName> ptr1(aQoSProfile);

	return Get(EPacketContextGetProfileName,ptr1);

	}

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

/** 

 * This function may be called by the client application.

 * It is a synchronous function.

 *

 * It allows a client to get details on the current amount of data transmitted & received over the airlink

 * since the context was activated.

 * 

 * @param aVolume : this is a reference to TDataVolume. 

 */

	{

	TPckg<TDataVolume> ptr1(aVolume);

	return Get(EPacketContextGetDataVolumeTransferred, ptr1);

	}

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

/** 

 * This function may be called by the client application.

 * It is an asynchronous function.

 *

 * It allows a client to be notified of a change in the volume of data transmitted/received over the airlink since the 

 * context was activated. The new volume is also passed back to the client. It should be noted that once the 

 * notification completes, the client must then re-post the notification if they wish to continue 

 * receiving further notifications.

 *

 * The notification will only complete whenever the change in volume increases by a client-specified amount (granularity).

 * The default granularity for each direction (rx/tx) is 4KB. 

 * 

 * @param aStatus : this is a reference to TRequestStatus.

 * @param aVolume : this is a reference to TDataVolume. 

 * @param aRcvdGranularity : this is a reference to a TUint value defining the granularity for the volume of received data

 * @param aSentGranularity : this is a reference to a TUint value defining the granularity for the volume of transmitted data

 */

	{

	__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.

 * It is a synchronous function.

 *

 * Allows a client to get the current connection speed. 

 *

 * @param aRate : reference to a TUint value that is the current connection bandwidth in bits per second.

 */

	{

	__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 application.

 * It is an asynchronous function.

 *

 * Allows a client to be notified whenever the current connection speed available changes. The new value of connection 

 * speed availability is also passed back. 

 *

 * @param aStatus : reference to a TReqStatus.

 * @param aRate : reference to a TUint value that is the current connection bandwidth in bits per second.

 */

	{

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

	TPtr8& ptr1=iEtelPacketContextPtrHolder->Set(CEtelPacketPtrHolder::ESlotNotifySpeed, aRate);

	Get(EPacketContextNotifyConnectionSpeedChange, aStatus, ptr1);

	}

EXPORT_C TInt RPacketContext::GetLastErrorCause(TInt& aError) const

/**

 * This function may be called by the client.

 *

 * This function will retrieve the most recent error to have occurred, passed back in the parameter aError. 

 * This may be used, for instance, to retrieve which error caused PPP to close down prematurely. 

 *

 * @param aError : this is the last error received/generated by the TSY

 */

	{

	TPckg<TInt> ptr1(aError);

	return Get(EPacketContextGetLastErrorCause, ptr1);

	}

EXPORT_C RPacketContext::TContextConfigGPRS::TContextConfigGPRS()

: TPacketDataConfigBase()

/**

 * Constructor for TContextConfigGPRS class

 *

 * This class contains member data compatible with parameters required for configuring a context

 * on the GPRS packet network. 

 *

 * 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;

	iAccessPointName.Zero();

	iAnonymousAccessReqd = ENotRequired;

	iPdpAddress.Zero();

	iPdpCompression = 0;

	iPdpType = EPdpTypeIPv4;

	};

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

//

// RPacketService

//

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

EXPORT_C RPacketService::RPacketService()

	:iEtelPacketPtrHolder(NULL) 

/**

 * Constructor for RPacketService class

 */

	{

	}

EXPORT_C void RPacketService::ConstructL()

/**

 * ConstructL for the RPacketService class

 *

 */

	{

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

	iEtelPacketPtrHolder = CPacketPtrHolder::NewL(CEtelPacketPtrHolder::EMaxNumPacketPtrSlots);

	}

EXPORT_C void RPacketService::Destruct()

/**

 * Destruct() for the RPacketService class

 *

 */

	{

	delete iEtelPacketPtrHolder;

	iEtelPacketPtrHolder = NULL;

	}	

EXPORT_C TInt RPacketService::Open(RPhone& aPhone)

/**

 * This function may be called by the client.

 *

 * It allows a client to create an RPacketService subsession from an existing RPhone session

 *

 * @param aPhone : a reference to an existing RPhone session the client has previously created.

 */

	{

	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;

	TIpcArgs args;

	args.Set(0,&KPacketName);

	args.Set(1,TIpcArgs::ENothing);

	args.Set(2,subSessionHandle);

	SetSessionHandle(*session);

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

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C void RPacketService::Close()

/**

 * This function may be called by the client.

 *

 * It allows a client to close its RPacketService subsession

 */

	{

	CloseSubSession(EEtelClose);

	Destruct();

	}

EXPORT_C void RPacketService::NotifyContextAdded(TRequestStatus& aStatus, TDes& aContextId) const

/**

 * This function may be called by the client.