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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // PACKETCONTEXTTSY.CPP

    15 // 

    16 //

    17 

    18 #include "pckttsy.h"

    19 #include "testdef.h"

    20 #include "etelpckt.h"

    21 #include "dpcktlog.h"

    22 #include <pcktcs.h>

    23 

    24 #include "coretsy.h"

    25 

    26 /**************************************************************************/

    27 //

    28 //	CGprsContextDGprsTsy

    29 //

    30 /**************************************************************************/

    31 

    32 CGprsContextDGprsTsy* CGprsContextDGprsTsy::NewL(CPhoneFactoryDummyBase* aFac)

    33 /**

    34  * NewL method - Standard 2-phase constructor

    35  */

    36 	{

    37 	LOGTEXT(_L8("CGprsContextDGprsTsy: NewL() method"));

    38 

    39 	CGprsContextDGprsTsy* subsession=new(ELeave) CGprsContextDGprsTsy(aFac);

    40 	CleanupStack::PushL(subsession);

    41 	subsession->ConstructL();

    42 	CleanupStack::Pop();

    43 	return subsession;

    44 	}

    45 

    46 void CGprsContextDGprsTsy::Init()

    47 	{}

    48 

    49 CGprsContextDGprsTsy::CGprsContextDGprsTsy(CPhoneFactoryDummyBase* aFac)

    50 	:CSubSessionExtDummyBase(aFac)

    51 	{

    52 	}

    53 

    54 void CGprsContextDGprsTsy::ConstructL()

    55 /**

    56  * ConstructL method

    57  */

    58 	{

    59 	LOGTEXT(_L8("CGprsContextDGprsTsy: Entered constructor"));

    60 	}

    61 

    62 CGprsContextDGprsTsy::~CGprsContextDGprsTsy()

    63 /**

    64  * Destructor

    65  */

    66 	{

    67 	LOGTEXT(_L8("CGprsContextDGprsTsy: Entered destructor"));

    68 	}

    69 

    70 CTelObject* CGprsContextDGprsTsy::OpenNewObjectByNameL(const TDesC& /*aName*/)

    71 /**

    72  * Opening object(s) from RPacketContext is not supported.

    73  */

    74 	{

    75 	LOGTEXT(_L8("CGprsContextDGprsTsy: OpenNewObjectByNameL() method - Not supported"));

    76 

    77 	User::Leave(KErrNotSupported);

    78 	return NULL;

    79 	}

    80 

    81 CTelObject* CGprsContextDGprsTsy::OpenNewObjectL(TDes& aNewName)

    82 /**

    83  * A new QoS opened by a client from an existing context will have its name allocated by 

    84  * the TSY.

    85  */

    86 	{

    87 	LOGTEXT(_L8("CGprsContextDGprsTsy: OpenNewObjectL() method"));

    88 	aNewName.Append(_L("PACKET_QOS"));

    89 	aNewName.AppendNum(++iGprsQoSObjectCount);

    90 

    91 	return CGprsQoSDGprsTsy::NewL(FacPtr());

    92 	}

    93 

    94 CTelObject::TReqMode CGprsContextDGprsTsy::ReqModeL(const TInt aIpc)

    95 /**

    96  * ReqModeL is called from the server's CTelObject::ReqAnalyserL in order to check the 

    97  * type of request it has. The following are example request types for this dummy TSY

    98  * All TSYs do not have to have these request types but they have been given

    99  * "sensible" values in this dummy TSY code.

   100  */	

   101 	{

   102 	LOGTEXT(_L8("CGprsContextDGprsTsy: ReqModeL() method"));

   103 	CTelObject::TReqMode ret=0;

   104 	switch (aIpc)

   105 		{

   106 		case EPacketContextSetConfig:

   107 		case EPacketContextActivate:

   108 		case EPacketContextDeactivate:

   109 		case EPacketContextDelete:

   110 		case EPacketContextLoanCommPort:

   111 		case EPacketContextRecoverCommPort:

   112 		case EPacketContextGetConfig:

   113 		case EPacketContextGetStatus:

   114 		case EPacketContextGetDataVolumeTransferred:

   115 		case EPacketContextGetLastErrorCause:

   116 		case EPacketContextGetConnectionSpeed:

   117 		case EPacketContextGetProfileName:

   118 		case EPacketContextInitialiseContext:

   119 		case EPacketContextEnumeratePacketFilters:

   120 		case EPacketContextGetPacketFilterInfo:

   121 		case EPacketContextAddPacketFilter:

   122 		case EPacketContextRemovePacketFilter:

   123 		case EPacketContextModifyActiveContext:

   124 		case EPacketContextGetDNSInfo:

   125 		case EPacketContextCreateNewTFT:

   126 		case EPacketContextDeleteTFT:

   127 		case EPacketAddMediaAuthorization:

   128 		case EPacketRemoveMediaAuthorization:

   129 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   130         case EPacketContextGetConnectionInfo:            		    

   131 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   132 			break;

   133 

   134 		case EPacketContextNotifyConfigChanged:

   135 		case EPacketContextNotifyStatusChange:

   136 		case EPacketContextNotifyDataTransferred:

   137 		case EPacketContextNotifyConnectionSpeedChange:

   138 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   139         case EPacketContextNotifyConnectionInfoChange:           		    

   140 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   141 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   142 			break;

   143 

   144 		default:

   145 			User::Leave(KErrNotSupported);

   146 			break;

   147 		}

   148 

   149 	return ret;

   150 	}

   151 

   152 TInt CGprsContextDGprsTsy::RegisterNotification(const TInt aIpc)

   153 /**

   154  * RegisterNotification is called when the server recognises that this notification

   155  * is being posted for the first time on this sub-session object.

   156  * It enables the TSY to "turn on" any regular notification messages that it may 

   157  * receive from the phone

   158  */

   159 	{

   160 	switch (aIpc)

   161 		{

   162 		case EPacketContextNotifyConfigChanged:

   163 			LOGTEXT(_L8("CGprsContextDGprsTsy: RegisterNotification - Config Changed"));

   164 			return KErrNone;

   165 		case EPacketContextNotifyStatusChange:

   166 			LOGTEXT(_L8("CGprsContextDGprsTsy: RegisterNotification - Status Change"));

   167 			return KErrNone;

   168 		case EPacketContextNotifyDataTransferred:

   169 			LOGTEXT(_L8("CGprsContextDGprsTsy: RegisterNotification - DataTransferred"));

   170 			return KErrNone;

   171 		case EPacketContextNotifyConnectionSpeedChange:

   172 			LOGTEXT(_L8("CGprsContextDGprsTsy: RegisterNotification - Connection Speed Change"));

   173 			return KErrNone;

   174 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   175         case EPacketContextNotifyConnectionInfoChange:

   176 			LOGTEXT(_L8("CGprsContextDGprsTsy: RegisterNotification - Connection Info Change"));

   177 			return KErrNone;                			

   178 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   179 		default:

   180 			// Unknown or invalid IPC

   181 			LOGTEXT(_L8("CGprsContextDGprsTsy: Register error, unknown IPC"));

   182 			return KErrNotSupported;

   183 		}

   184 	}

   185 

   186 TInt CGprsContextDGprsTsy::DeregisterNotification(const TInt aIpc)

   187 /**

   188  * DeregisterNotification is called when the server recognises that this notification

   189  * will not be posted again because the last client to have a handle on this sub-session

   190  * object has just closed the handle.

   191  * It enables the TSY to "turn off" any regular notification messages that it may 

   192  * receive from the phone.

   193  */

   194 	{

   195 	switch (aIpc)

   196 		{

   197 		case EPacketContextNotifyConfigChanged:

   198 			LOGTEXT(_L8("CGprsContextDGprsTsy: DeregisterNotification - Config Changed"));

   199 			return KErrNone;

   200 		case EPacketContextNotifyStatusChange:

   201 			LOGTEXT(_L8("CGprsContextDGprsTsy: DeregisterNotification - Status Change"));

   202 			return KErrNone;

   203 		case EPacketContextNotifyDataTransferred:

   204 			LOGTEXT(_L8("CGprsContextDGprsTsy: DeregisterNotification - DataTransferred"));

   205 			return KErrNone;

   206 		case EPacketContextNotifyConnectionSpeedChange:

   207 			LOGTEXT(_L8("CGprsContextDGprsTsy: DeregisterNotification - Connection Speed Change"));

   208 			return KErrNone;

   209 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   210 		case EPacketContextNotifyConnectionInfoChange:

   211 			LOGTEXT(_L8("CGprsContextDGprsTsy: DeregisterNotification - Connection Info Change"));

   212 			return KErrNone;						

   213 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   214 		default:

   215 			// Unknown or invalid IPC

   216 			LOGTEXT(_L8("CGprsContextDGprsTsy: Deregister error, unknown IPC"));

   217 			return KErrNotSupported;

   218 		}

   219 	}

   220 

   221 TInt CGprsContextDGprsTsy::NumberOfSlotsL(const TInt aIpc)

   222 /**

   223  * NumberOfSlotsL is called by the server when it is registering a new notification.

   224  * It enables the TSY to tell the server how many buffer slots to allocate for

   225  * "repost immediately" notifications that may trigger before clients collect them.

   226  */

   227 	{

   228 	TInt numberOfSlots=1;

   229 	switch (aIpc)

   230 		{

   231 		case EPacketContextNotifyConfigChanged:

   232 		case EPacketContextNotifyStatusChange:

   233 		case EPacketContextNotifyDataTransferred:

   234         case EPacketContextNotifyConnectionSpeedChange:

   235 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   236         case EPacketContextNotifyConnectionInfoChange:                        

   237 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   238 			LOGTEXT(_L8("CGprsDGprsTsy: Registered with 5 slots"));

   239 			numberOfSlots=5;

   240 			break;

   241 		default:

   242 			// Unknown or invalid IPC

   243 			LOGTEXT(_L8("CGprsContextDGprsTsy: Number of Slots error, unknown IPC"));

   244 			User::Leave(KErrNotSupported);

   245 			break;

   246 		}  

   247 	return numberOfSlots;

   248 	}

   249 

   250 

   251 TInt CGprsContextDGprsTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

   252 							  const TDataPackage& aPackage)

   253 /**

   254  * ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request 

   255  * for the TSY to process. A request handle, request type and request data are passed 

   256  * to the TSY

   257  */

   258 	{

   259 	LOGTEXT(_L8("CGprsContextDGprsTsy: ExtFunc() called"));

   260 

   261 	TAny* dataPtr=aPackage.Ptr1();

   262 	TAny* dataPtr2=aPackage.Ptr2();

   263 

   264 	switch (aIpc)

   265 		{

   266 		case EPacketContextSetConfig:

   267 			return SetConfig(aTsyReqHandle, aPackage.Des1n());

   268 		case EPacketContextSetConfigCancel:

   269 			return SetConfigCancel(aTsyReqHandle);

   270 		case EPacketContextGetConfig:

   271 			return GetConfig(aTsyReqHandle, aPackage.Des1n());

   272 		case EPacketContextGetConfigCancel:

   273 			return GetConfigCancel(aTsyReqHandle);

   274 		case EPacketContextNotifyConfigChanged:

   275 			return NotifyConfigChanged(aTsyReqHandle, aPackage.Des1n());

   276 		case EPacketContextNotifyConfigChangedCancel:

   277 			return NotifyConfigChangedCancel(aTsyReqHandle);

   278 		case EPacketContextActivate:

   279 			return Activate(aTsyReqHandle);

   280 		case EPacketContextActivateCancel:

   281 			return ActivateCancel(aTsyReqHandle);

   282 		case EPacketContextDeactivate:

   283 			return Deactivate(aTsyReqHandle);

   284 		case EPacketContextDeactivateCancel:

   285 			return DeactivateCancel(aTsyReqHandle);

   286 		case EPacketContextDelete:

   287 			return Delete(aTsyReqHandle);

   288 		case EPacketContextDeleteCancel:

   289 			return DeleteCancel(aTsyReqHandle);

   290 		case EPacketContextLoanCommPort:

   291 			return LoanCommPort(aTsyReqHandle,

   292 			REINTERPRET_CAST(RCall::TCommPort*, dataPtr));

   293 		case EPacketContextLoanCommPortCancel:

   294 			return LoanCommPortCancel(aTsyReqHandle);

   295 		case EPacketContextRecoverCommPort:

   296 			return RecoverCommPort(aTsyReqHandle);

   297 		case EPacketContextRecoverCommPortCancel:

   298 			return RecoverCommPortCancel(aTsyReqHandle);

   299 		case EPacketContextGetStatus:

   300 			return GetStatus(aTsyReqHandle,

   301 			REINTERPRET_CAST(RPacketContext::TContextStatus*, dataPtr));

   302 		case EPacketContextNotifyStatusChange:

   303 			return NotifyStatusChange(aTsyReqHandle,

   304 			REINTERPRET_CAST(RPacketContext::TContextStatus*, dataPtr));

   305 		case EPacketContextNotifyStatusChangeCancel:

   306 			return NotifyStatusChangeCancel(aTsyReqHandle);

   307 		case EPacketContextGetDataVolumeTransferred:

   308 			return GetDataVolumeTransferred(aTsyReqHandle,

   309 			REINTERPRET_CAST(RPacketContext::TDataVolume*, dataPtr));

   310 		case EPacketContextGetDataVolumeTransferredCancel:

   311 			return GetDataVolumeTransferredCancel(aTsyReqHandle);

   312 		case EPacketContextGetConnectionSpeed:

   313 			return GetConnectionSpeed(aTsyReqHandle,

   314 				REINTERPRET_CAST(TUint*, dataPtr));

   315 		case EPacketContextNotifyConnectionSpeedChange:

   316 			return NotifyConnectionSpeedChange(aTsyReqHandle,

   317 				REINTERPRET_CAST(TUint*, dataPtr));

   318 		case EPacketContextNotifyDataTransferred:

   319 			return NotifyDataTransferred(aTsyReqHandle,

   320 			REINTERPRET_CAST(RPacketContext::TDataVolume*, dataPtr),

   321 			REINTERPRET_CAST(RPacketContext::TNotifyDataTransferredRequest*, dataPtr2));

   322 		case EPacketContextNotifyDataTransferredCancel:

   323 			return NotifyDataTransferredCancel(aTsyReqHandle);

   324 		case EPacketContextGetLastErrorCause:

   325 			return GetLastErrorCause(aTsyReqHandle,

   326 			REINTERPRET_CAST(TInt*, dataPtr));

   327 		case EPacketContextGetProfileName:

   328 			return GetProfileName(aTsyReqHandle,

   329 			REINTERPRET_CAST(TName*, dataPtr));

   330 		case EPacketContextInitialiseContext:

   331 			return InitialiseContext(aTsyReqHandle, aPackage.Des1n());

   332 		case EPacketContextInitialiseContextCancel:

   333 			return InitialiseContextCancel(aTsyReqHandle);

   334 		case EPacketContextEnumeratePacketFilters:

   335 			return EnumeratePacketFilters(aTsyReqHandle,

   336 				REINTERPRET_CAST(TInt*, dataPtr));

   337 		case EPacketContextEnumeratePacketFiltersCancel:

   338 			return EnumeratePacketFiltersCancel(aTsyReqHandle);

   339 		case EPacketContextGetPacketFilterInfo:

   340 			return GetPacketFilterInfo(aTsyReqHandle,

   341 				REINTERPRET_CAST(TInt*, dataPtr),

   342 				aPackage.Des2n());

   343 		case EPacketContextGetPacketFilterInfoCancel:

   344 			return GetPacketFilterInfoCancel(aTsyReqHandle);

   345 		case EPacketContextAddPacketFilter:

   346 			return AddPacketFilter(aTsyReqHandle, aPackage.Des1n());

   347 		case EPacketContextAddPacketFilterCancel:

   348 			return AddPacketFilterCancel(aTsyReqHandle);

   349 		case EPacketContextRemovePacketFilter:

   350 			return RemovePacketFilter(aTsyReqHandle,

   351 				REINTERPRET_CAST(TInt*, dataPtr));

   352 		case EPacketContextRemovePacketFilterCancel:

   353 			return RemovePacketFilterCancel(aTsyReqHandle);

   354 		case EPacketContextModifyActiveContext:

   355 			return ModifyActiveContext(aTsyReqHandle);

   356 		case EPacketContextModifyActiveContextCancel:

   357 			return ModifyActiveContextCancel(aTsyReqHandle);

   358 		case EPacketContextGetDNSInfo:

   359 			return GetDnsInfo(aTsyReqHandle, aPackage.Des1n());

   360 		case EPacketContextGetDNSInfoCancel:

   361 			return GetDnsInfoCancel(aTsyReqHandle);

   362 		case EPacketContextCreateNewTFT:  

   363 			return CreateNewTFT(aTsyReqHandle,

   364 				REINTERPRET_CAST(TInt*, dataPtr));

   365 		case EPacketContextDeleteTFT:

   366 			return DeleteTFT(aTsyReqHandle);

   367 		case EPacketAddMediaAuthorization:

   368 			return GetAddMediaAuthorization(aTsyReqHandle, aPackage.Des1n());

   369 		case EPacketAddMediaAuthorizationCancel:

   370 			return GetAddMediaAuthorizationCancel(aTsyReqHandle);

   371 		case EPacketRemoveMediaAuthorization:

   372 			return GetRemoveMediaAuthorization(aTsyReqHandle, reinterpret_cast<RPacketContext::TAuthorizationToken*>(dataPtr));

   373 		case EPacketRemoveMediaAuthorizationCancel:

   374 			return GetRemoveMediaAuthorizationCancel(aTsyReqHandle);

   375 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   376         case EPacketContextGetConnectionInfo:

   377             return GetConnectionInfo( aTsyReqHandle, aPackage.Des1n() ); 

   378         case EPacketContextNotifyConnectionInfoChange:

   379             return NotifyConnectionInfoChange( aTsyReqHandle, aPackage.Des1n() ); 			

   380 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   381 		default:

   382 			return KErrNotSupported;

   383 		}

   384 	}

   385 

   386 TInt CGprsContextDGprsTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   387 /**

   388  * CancelService is called by the server when it is "cleaning-up" any still outstanding

   389  * asynchronous requests before closing a client's sub-session.

   390  * This will happen if a client closes its R-class handle without cancelling outstanding

   391  * asynchronous requests.

   392  */

   393 	{

   394 	LOGTEXT(_L8("CGprsContextDGprsTsy: - CancelService called"));

   395 	switch (aIpc)

   396 		{

   397 		case EPacketContextSetConfig:

   398 			return SetConfigCancel(aTsyReqHandle);

   399 		case EPacketContextGetConfig:

   400 			return GetConfigCancel(aTsyReqHandle);

   401 		case EPacketContextNotifyConfigChanged:

   402 			return NotifyConfigChangedCancel(aTsyReqHandle);

   403 		case EPacketContextActivate:

   404 			return ActivateCancel(aTsyReqHandle);

   405 		case EPacketContextDeactivate:

   406 			return DeactivateCancel(aTsyReqHandle);

   407 		case EPacketContextDelete:

   408 			return DeleteCancel(aTsyReqHandle);

   409 		case EPacketContextLoanCommPort:

   410 			return LoanCommPortCancel(aTsyReqHandle);

   411 		case EPacketContextRecoverCommPort:

   412 			return RecoverCommPortCancel(aTsyReqHandle);

   413 		case EPacketContextNotifyStatusChange:

   414 			return NotifyStatusChangeCancel(aTsyReqHandle);

   415 		case EPacketContextNotifyDataTransferred:

   416 			return NotifyDataTransferredCancel(aTsyReqHandle);

   417 		case EPacketContextNotifyConnectionSpeedChange:

   418 			return NotifyConnectionSpeedChangeCancel(aTsyReqHandle);

   419 		case EPacketContextGetDataVolumeTransferred:

   420 			return GetDataVolumeTransferredCancel(aTsyReqHandle);

   421 		case EPacketContextInitialiseContext:

   422 			return InitialiseContextCancel(aTsyReqHandle);

   423 		case EPacketContextEnumeratePacketFilters:

   424 			return EnumeratePacketFiltersCancel(aTsyReqHandle);

   425 		case EPacketContextGetPacketFilterInfo:

   426 			return GetPacketFilterInfoCancel(aTsyReqHandle);

   427 		case EPacketContextAddPacketFilter:

   428 			return AddPacketFilterCancel(aTsyReqHandle);

   429 		case EPacketContextRemovePacketFilter:

   430 			return RemovePacketFilterCancel(aTsyReqHandle);

   431 		case EPacketContextModifyActiveContext:

   432 			return ModifyActiveContextCancel(aTsyReqHandle);

   433 		case EPacketContextGetDNSInfo:

   434 			return GetDnsInfoCancel(aTsyReqHandle);

   435 		case EPacketContextCreateNewTFT:

   436 			return CreateNewTFTCancel(aTsyReqHandle);

   437 		case EPacketContextDeleteTFT:

   438 			return DeleteTFTCancel(aTsyReqHandle);

   439 		case EPacketAddMediaAuthorization:

   440 			return GetAddMediaAuthorizationCancel(aTsyReqHandle);

   441 		case EPacketRemoveMediaAuthorization:

   442 			return GetRemoveMediaAuthorizationCancel(aTsyReqHandle);

   443 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   444         case EPacketContextGetConnectionInfo:

   445             return GetConnectionInfoCancel(aTsyReqHandle);

   446         case EPacketContextNotifyConnectionInfoChange:

   447             return NotifyConnectionInfoChangeCancel(aTsyReqHandle);            			

   448 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   449 		default:

   450 			return KErrGeneral; 

   451 		} 

   452 	}

   453 

   454 /***********************************************************************************/

   455 //

   456 // The following methods are called from ExtFunc and/or CancelService.

   457 // Each of these will process a TSY request or cancel a TSY request

   458 // Here, example values are returned or checked within this dummy TSY in order to ensure

   459 // that the integrity of the data passed to/from client is maintained

   460 //

   461 /***********************************************************************************/

   462 

   463 TInt CGprsContextDGprsTsy::GetDnsInfo(const TTsyReqHandle aTsyReqHandle, const TDesC8* aDnsInfo)

   464 	{

   465 /**

   466  * GetDnsInfo method to extract DNS server names from context

   467  *

   468  * @param aStatus TRequestStatus object with which error code is returned

   469  * @param aDnsInfo packaged TDnsInfoV2 object passed as TDes8

   470  *

   471  * GetDNSInfo() is needed when the client uses dynamic IPv4 PDP addresses. 

   472  * After the context is activated the client needs to know the actual primary 

   473  * and secondary DNS addresses to use when sending packet data. As the network 

   474  * may have supplied these addresses there is a need for an API method to get 

   475  * these addresses from the TSY.

   476  */

   477 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetDnsInfo called"));

   478 	

   479 	User::After(300000); // wait to have KRequestPending

   480 	if(!iGetDNSInfo++)

   481 		{

   482 		RPacketContext::TTDnsInfoV2Pckg* dnsInfoV2Pckg = (RPacketContext::TTDnsInfoV2Pckg*)aDnsInfo;

   483 		RPacketContext::TDnsInfoV2& dnsInfoV2 = (*dnsInfoV2Pckg)();

   484 

   485 		dnsInfoV2.iPrimaryDns = DPCKTTSY_DNS_SERVER1;

   486 		dnsInfoV2.iSecondaryDns = DPCKTTSY_DNS_SERVER2;

   487 		ReqCompleted(aTsyReqHandle,KErrNone);

   488 		}

   489 	iTsyAsyncReqHandle = aTsyReqHandle;

   490 	return KErrNone;

   491 	}

   492 

   493 TInt CGprsContextDGprsTsy::GetDnsInfoCancel(const TTsyReqHandle aTsyReqHandle) 

   494 /**

   495  * GetDnsInfoCancel - Cancels an asynchronous GetDnsInfo method.

   496  */

   497 	{

   498 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetDnsInfoCancel called"));

   499 	User::After(300000); // wait to have KRequestPending

   500 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   501 		ReqCompleted(aTsyReqHandle,KErrCancel);

   502 	else

   503 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   504 	return KErrNone;

   505 	}

   506 

   507 

   508 TInt CGprsContextDGprsTsy::SetConfig(const TTsyReqHandle aTsyReqHandle,const TDesC8* aConfig)

   509 	{

   510 	LOGTEXT(_L8("CGprsContextDGprsTsy::SetConfig called"));

   511 

   512 	User::After(300000); // wait to have KRequestPending

   513 	TPckg<TPacketDataConfigBase>* configBasePckg = (TPckg<TPacketDataConfigBase>*)aConfig;

   514 	TPacketDataConfigBase& configBase = (*configBasePckg)();

   515 

   516 	// GPRS configuration

   517 	if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)

   518 		{

   519 		TPckg<RPacketContext::TContextConfigGPRS>* contextConfigGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aConfig;

   520 		RPacketContext::TContextConfigGPRS& contextConfig = (*contextConfigGPRSPckg)();

   521 		

   522 		if ((contextConfig.iAccessPointName != DPCKTTSY_ACCESS_POINT1)	

   523 			||(contextConfig.iAnonymousAccessReqd != DPCKTTSY_ANONYMOUS_ACCESS1)

   524 			||(contextConfig.iPdpAddress != DPCKTTSY_PDP_ADDRESS1)

   525 			||(contextConfig.iPdpCompression != DPCKTTSY_COMPRESSION1)

   526 			||(contextConfig.iPdpType != DPCKTTSY_PDP_TYPE1)

   527 			||(contextConfig.iUseEdge != DPCKTTSY_EGPRS_REQUIRED)

   528 			||(contextConfig.iProtocolConfigOption.iAuthInfo.iUsername != DPCKTTSY_USER_NAME1)

   529 			||(contextConfig.iProtocolConfigOption.iAuthInfo.iPassword != DPCKTTSY_PASSWORD1)

   530 			||(contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol != DPCKTTSY_PROTOCOL_TYPE1_0))

   531 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   532 		else 

   533 			{

   534 			if(!iSetConfig++)

   535 				ReqCompleted(aTsyReqHandle,KErrNone);

   536 			else

   537 				iSetConfig = 0; //reset for V2 tests

   538 			iTsyAsyncReqHandle = aTsyReqHandle;

   539 			}

   540 		}

   541 	else if (configBase.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)

   542 		{

   543 		TPckg<RPacketContext::TContextConfigR99_R4>* configParam = (TPckg<RPacketContext::TContextConfigR99_R4>*)aConfig;

   544 		RPacketContext::TContextConfigR99_R4& contextConfig = (*configParam)();

   545 		

   546 		if(((contextConfig.iAccessPointName).Compare(DPCKTTSY_ACCESS_POINT1) != KErrNone) ||

   547 			   ((contextConfig.iPdpAddress).Compare(DPCKTTSY_PDP_ADDRESS1) != KErrNone) ||

   548 			   (contextConfig.iPdpType != DPCKTTSY_PDP_TYPE1) ||

   549 			   contextConfig.iUseEdge != DPCKTTSY_EGPRS_REQUIRED)

   550 				ReqCompleted(aTsyReqHandle,KErrCorrupt);

   551 		else

   552 			{

   553 			if(!iSetConfig++)

   554 				ReqCompleted(aTsyReqHandle,KErrNone);

   555 			else

   556 				iSetConfig = 0; //reset for V2 tests

   557 			iTsyAsyncReqHandle = aTsyReqHandle;

   558 			}

   559 		}

   560 	else if (configBase.ExtensionId()==TPacketDataConfigBase::TPacketDataConfigBase::KConfigRel5)

   561 		{

   562 		TPckg<RPacketContext::TContextConfig_R5>* configParam = (TPckg<RPacketContext::TContextConfig_R5>*)aConfig;

   563 		RPacketContext::TContextConfig_R5& contextConfig = (*configParam)();

   564 		

   565 		if(((contextConfig.iAccessPointName).Compare(DPCKTTSY_ACCESS_POINT1) != KErrNone) ||

   566 			((contextConfig.iPdpAddress).Compare(DPCKTTSY_PDP_ADDRESS1) != KErrNone) ||

   567 			(contextConfig.iPdpType != DPCKTTSY_PDP_TYPE1) ||

   568 			(contextConfig.iUseEdge != DPCKTTSY_EGPRS_REQUIRED) || 

   569 			(contextConfig.iPdpDataCompression != DPCKTTSY_DATACOMPRESSION_EV42) ||

   570 			(contextConfig.iPdpHeaderCompression != DPCKTTSY_HEADERCOMPRESSION_ERFC1144))

   571 				ReqCompleted(aTsyReqHandle,KErrCorrupt);

   572 		else

   573 			{

   574 			if(!iSetConfig++)

   575 				ReqCompleted(aTsyReqHandle,KErrNone);

   576 			else

   577 				iSetConfig = 0; //reset for V2 tests

   578 			iTsyAsyncReqHandle = aTsyReqHandle;

   579 			}

   580 		}

   581 	else if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigMBMS)

   582 		{

   583 		TPckg<RPacketMbmsContext::TContextConfigMbmsV1>* contextConfigMbmsPckg = (TPckg<RPacketMbmsContext::TContextConfigMbmsV1>*)aConfig;

   584 		RPacketMbmsContext::TContextConfigMbmsV1& contextConfig = (*contextConfigMbmsPckg)();

   585 		

   586 		if ((contextConfig.iMbmsAccessBearer != DPCKTTSY_MBMS_ACCESSBEARER_ONE)	

   587 			||(contextConfig.iMbmsServicePriority != DPCKTTSY_MBMS_SERVICEPRIORITY_ONE)

   588 			||(contextConfig.iMbmsServiceMode != DPCKTTSY_MBMS_SERVICEMODE_ONE)

   589 			||(contextConfig.iMbmsSessionFlag != DPCKTTSY_MBMS_SESSION_FLAG_TRUE)

   590 			||(contextConfig.iTmgi.GetMCC() != DPCKTTSY_MBMS_MCC_ONE)

   591 			||(contextConfig.iTmgi.GetMNC() != DPCKTTSY_MBMS_MNC_ONE)

   592 			||(contextConfig.iTmgi.GetServiceId() != DPCKTTSY_MBMS_SERVICEID_ONE))

   593 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   594 		else

   595 			{

   596 			if(!iSetConfig++)

   597 				{

   598 				ReqCompleted(aTsyReqHandle,KErrNone);

   599 				}

   600 			else

   601 				{

   602 				iSetConfig = 0; //reset for V2 tests

   603 				}

   604 			iTsyAsyncReqHandle = aTsyReqHandle;

   605 			}

   606 		}

   607 		

   608 	return KErrNone;

   609 	}

   610 

   611 TInt CGprsContextDGprsTsy::SetConfigCancel(const TTsyReqHandle aTsyReqHandle)

   612 	{

   613 	LOGTEXT(_L8("CGprsContextDGprsTsy::SetConfigCancel called"));

   614 	User::After(300000); // wait to have KRequestPending

   615 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   616 		ReqCompleted(aTsyReqHandle,KErrCancel);

   617 	else

   618 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   619 	return KErrNone;

   620 	}

   621 

   622 TInt CGprsContextDGprsTsy::GetConfig(const TTsyReqHandle aTsyReqHandle,TDes8* aConfig)

   623 	{

   624 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetConfig called"));

   625 

   626 	User::After(300000); // wait to have KRequestPending

   627 	TPckg<TPacketDataConfigBase>* configBasePckg = (TPckg<TPacketDataConfigBase>*)aConfig;

   628 	TPacketDataConfigBase& configBase = (*configBasePckg)();

   629 

   630 	if(!iGetConfig++)

   631 		{

   632 		if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)

   633 			{

   634 			

   635 			TPckg<RPacketContext::TContextConfigGPRS>* contextConfigGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aConfig;

   636 			RPacketContext::TContextConfigGPRS& contextConfig = (*contextConfigGPRSPckg)();

   637 

   638 			contextConfig.iAccessPointName = DPCKTTSY_ACCESS_POINT2;

   639 			contextConfig.iAnonymousAccessReqd = DPCKTTSY_ANONYMOUS_ACCESS2;

   640 			contextConfig.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;

   641 			contextConfig.iPdpCompression = DPCKTTSY_COMPRESSION2;

   642 			contextConfig.iPdpType = DPCKTTSY_PDP_TYPE2;

   643 			contextConfig.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;

   644 			contextConfig.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   645 			contextConfig.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   646 			contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   647 			contextConfig.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   648 			

   649 			ReqCompleted(aTsyReqHandle,KErrNone);

   650 			}

   651 		else if (configBase.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)

   652 			{

   653 			TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aConfig;

   654 			RPacketContext::TContextConfigR99_R4& contextConfig = (*contextConfigR99Pckg)();

   655 

   656 			contextConfig.iAccessPointName = DPCKTTSY_ACCESS_POINT2;

   657 			contextConfig.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;

   658 			contextConfig.iPdpType = DPCKTTSY_PDP_TYPE2;

   659 			contextConfig.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;

   660 			contextConfig.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   661 			contextConfig.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   662 			contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   663 			contextConfig.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   664 			contextConfig.iPFI = DPCKTTSY_PFICONTEXT_SMS;

   665 			

   666 			ReqCompleted(aTsyReqHandle,KErrNone);

   667 			}

   668 		else if (configBase.ExtensionId()==TPacketDataConfigBase::KConfigRel5)

   669 			{

   670 			TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aConfig;

   671 			RPacketContext::TContextConfig_R5& contextConfig = (*contextConfigR5Pckg)();

   672 

   673 			contextConfig.iAccessPointName = DPCKTTSY_ACCESS_POINT2;

   674 			contextConfig.iPdpAddress = DPCKTTSY_PDP_ADDRESS2;

   675 			contextConfig.iPdpType = DPCKTTSY_PDP_TYPE2;

   676 			contextConfig.iUseEdge = DPCKTTSY_EGPRS_NOTREQUIRED;

   677 			contextConfig.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   678 			contextConfig.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   679 			contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   680 			contextConfig.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   681 			contextConfig.iPFI = DPCKTTSY_PFICONTEXT_SMS;

   682 			contextConfig.iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV44;

   683 			contextConfig.iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC2507;

   684 			

   685 			ReqCompleted(aTsyReqHandle,KErrNone);

   686 			}

   687 		else if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigMBMS)

   688 			{

   689 			

   690 			TPckg<RPacketMbmsContext::TContextConfigMbmsV1>* contextConfigMbmsPckg = (TPckg<RPacketMbmsContext::TContextConfigMbmsV1>*)aConfig;

   691 			RPacketMbmsContext::TContextConfigMbmsV1& contextConfig = (*contextConfigMbmsPckg)();

   692 

   693 			contextConfig.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_ONE;	

   694 			contextConfig.iMbmsServicePriority = DPCKTTSY_MBMS_SERVICEPRIORITY_ONE;

   695 			contextConfig.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_ONE;

   696 			contextConfig.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_ONE);

   697 			contextConfig.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_ONE);

   698 			contextConfig.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_ONE);

   699 

   700 			ReqCompleted(aTsyReqHandle,KErrNone);

   701 			}	

   702 		}

   703 	iTsyAsyncReqHandle = aTsyReqHandle;

   704 	return KErrNone;

   705 	}

   706 

   707 TInt CGprsContextDGprsTsy::GetConfigCancel(const TTsyReqHandle aTsyReqHandle)

   708 	{

   709 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetConfigCancel called"));

   710 	User::After(300000); // wait to have KRequestPending

   711 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   712 		ReqCompleted(aTsyReqHandle,KErrCancel);

   713 	else

   714 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   715 	return KErrNone;

   716 	}

   717 

   718 TInt CGprsContextDGprsTsy::NotifyConfigChanged(const TTsyReqHandle aTsyReqHandle, TDes8* aConfig)

   719 	{

   720 	TPckg<TPacketDataConfigBase>* configBasePckg = (TPckg<TPacketDataConfigBase>*)aConfig;

   721 	TPacketDataConfigBase& configBase = (*configBasePckg)();

   722 

   723 	LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyConfigChanged called"));

   724 

   725 	User::After(300000); // wait to have KRequestPending

   726 	if (!iNotifyConfigChanged++)

   727 		{

   728 		if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)

   729 			{

   730 			TPckg<RPacketContext::TContextConfigGPRS>* contextConfigGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aConfig;

   731 			RPacketContext::TContextConfigGPRS& contextConfigV1 = (*contextConfigGPRSPckg)();

   732 

   733 			contextConfigV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   734 			contextConfigV1.iAnonymousAccessReqd = DPCKTTSY_ANONYMOUS_ACCESS1;

   735 			contextConfigV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   736 			contextConfigV1.iPdpCompression = DPCKTTSY_COMPRESSION1;

   737 			contextConfigV1.iPdpType = DPCKTTSY_PDP_TYPE1;

   738 			contextConfigV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   739 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   740 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   741 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   742 			contextConfigV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   743 

   744 			ReqCompleted(aTsyReqHandle,KErrNone);

   745 			}

   746 		else if (configBase.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)

   747 			{

   748 			TPckg<RPacketContext::TContextConfigR99_R4>* contextConfigR99Pckg = (TPckg<RPacketContext::TContextConfigR99_R4>*)aConfig;

   749 			RPacketContext::TContextConfigR99_R4& contextConfigV1 = (*contextConfigR99Pckg)();

   750 

   751 			contextConfigV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   752 			contextConfigV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   753 			contextConfigV1.iPdpType = DPCKTTSY_PDP_TYPE1;

   754 			contextConfigV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   755 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   756 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   757 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   758 			contextConfigV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   759 			contextConfigV1.iPFI = DPCKTTSY_PFICONTEXT_SIG;

   760 

   761 			ReqCompleted(aTsyReqHandle,KErrNone);

   762 			}

   763 		else if (configBase.ExtensionId()==TPacketDataConfigBase::KConfigRel5)

   764 			{

   765 			TPckg<RPacketContext::TContextConfig_R5>* contextConfigR5Pckg = (TPckg<RPacketContext::TContextConfig_R5>*)aConfig;

   766 			RPacketContext::TContextConfig_R5& contextConfigV1 = (*contextConfigR5Pckg)();

   767 

   768 			contextConfigV1.iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   769 			contextConfigV1.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   770 			contextConfigV1.iPdpType = DPCKTTSY_PDP_TYPE1;

   771 			contextConfigV1.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   772 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   773 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   774 			contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   775 			contextConfigV1.iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   776 			contextConfigV1.iPFI = DPCKTTSY_PFICONTEXT_SIG;

   777 			contextConfigV1.iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV42;

   778 			contextConfigV1.iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC1144;

   779 

   780 			ReqCompleted(aTsyReqHandle,KErrNone);

   781 			}

   782 		else if(configBase.ExtensionId()==TPacketDataConfigBase::KConfigMBMS)

   783 			{

   784 			TPckg<RPacketMbmsContext::TContextConfigMbmsV1>* contextConfigMbmsPckg = (TPckg<RPacketMbmsContext::TContextConfigMbmsV1>*)aConfig;

   785 			RPacketMbmsContext::TContextConfigMbmsV1& contextConfig = (*contextConfigMbmsPckg)();

   786 

   787 			contextConfig.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_ONE;	

   788 			contextConfig.iMbmsServicePriority = DPCKTTSY_MBMS_SERVICEPRIORITY_ONE;

   789 			contextConfig.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_ONE;

   790 			contextConfig.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_ONE);

   791 			contextConfig.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_ONE);

   792 			contextConfig.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_ONE);

   793 

   794 			ReqCompleted(aTsyReqHandle,KErrNone);

   795 			}	

   796 		}

   797 	iTsyAsyncReqHandle = aTsyReqHandle;

   798 	return KErrNone;

   799 	}

   800 

   801 TInt CGprsContextDGprsTsy::NotifyConfigChangedCancel(const TTsyReqHandle aTsyReqHandle)

   802 	{

   803 	LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyConfigChangedCancel called"));

   804 	User::After(300000); // wait to have KRequestPending

   805 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   806 		ReqCompleted(aTsyReqHandle,KErrCancel);

   807 	else

   808 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   809 	return KErrNone;

   810 	}

   811 

   812 TInt CGprsContextDGprsTsy::Deactivate(const TTsyReqHandle aTsyReqHandle)

   813 	{

   814 	LOGTEXT(_L8("CGprsContextDGprsTsy::Deactivate called"));

   815 	User::After(300000); // wait to have KRequestPending

   816 	if(!iDeactivate++)

   817 		ReqCompleted(aTsyReqHandle,KErrNone);

   818 	iTsyAsyncReqHandle = aTsyReqHandle;

   819 	return KErrNone;

   820 	}

   821 

   822 TInt CGprsContextDGprsTsy::DeactivateCancel(const TTsyReqHandle aTsyReqHandle)

   823 	{

   824 	LOGTEXT(_L8("CGprsContextDGprsTsy::DeactivateCancel called"));

   825 	User::After(300000); // wait to have KRequestPending

   826 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   827 		ReqCompleted(aTsyReqHandle,KErrCancel);

   828 	else

   829 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   830 	return KErrNone;

   831 	}

   832 	

   833 TInt CGprsContextDGprsTsy::Activate(const TTsyReqHandle aTsyReqHandle)

   834 	{

   835 	LOGTEXT(_L8("CGprsContextDGprsTsy::Activate called"));

   836 	User::After(300000); // wait to have KRequestPending

   837 	if(!iActivate++)

   838 		ReqCompleted(aTsyReqHandle,KErrNone);

   839 	iTsyAsyncReqHandle = aTsyReqHandle;

   840 	return KErrNone;

   841 	}

   842 

   843 TInt CGprsContextDGprsTsy::ActivateCancel(const TTsyReqHandle aTsyReqHandle)

   844 	{

   845 	LOGTEXT(_L8("CGprsContextDGprsTsy::ActivateCancel called"));

   846 	User::After(300000); // wait to have KRequestPending

   847 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   848 		ReqCompleted(aTsyReqHandle,KErrCancel);

   849 	else

   850 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   851 	return KErrNone;

   852 	}

   853 

   854 TInt CGprsContextDGprsTsy::Delete(const TTsyReqHandle aTsyReqHandle)

   855 	{

   856 	LOGTEXT(_L8("CGprsContextDGprsTsy::Delete called"));

   857 	User::After(300000); // wait to have KRequestPending

   858 	if(!iDelete++)

   859 		ReqCompleted(aTsyReqHandle,KErrNone);

   860 	iTsyAsyncReqHandle = aTsyReqHandle;

   861 	return KErrNone;

   862 	}

   863 

   864 TInt CGprsContextDGprsTsy::DeleteCancel(const TTsyReqHandle aTsyReqHandle)

   865 	{

   866 	LOGTEXT(_L8("CGprsContextDGprsTsy::DeleteCancel called"));

   867 	User::After(300000); // wait to have KRequestPending

   868 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   869 		ReqCompleted(aTsyReqHandle,KErrCancel);

   870 	else

   871 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   872 	return KErrNone;

   873 	}

   874 

   875 TInt CGprsContextDGprsTsy::LoanCommPort(const TTsyReqHandle aTsyReqHandle,RCall::TCommPort* aDataPort)

   876 	{

   877 	LOGTEXT(_L8("CGprsContextDGprsTsy::LoanCommPort called"));

   878 	User::After(300000); // wait to have KRequestPending

   879 	if(!iLoanCommPort++)

   880 		{

   881 		aDataPort->iCsy = DPCKTTSY_CSY;

   882 		aDataPort->iPort = DPCKTTSY_PORT;

   883 		ReqCompleted(aTsyReqHandle,KErrNone);

   884 		}

   885 	iTsyAsyncReqHandle = aTsyReqHandle;

   886 	return KErrNone;

   887 	}

   888 

   889 TInt CGprsContextDGprsTsy::LoanCommPortCancel(const TTsyReqHandle aTsyReqHandle)

   890 	{

   891 	LOGTEXT(_L8("CGprsContextDGprsTsy::LoanCommPortCancel called"));

   892 	User::After(300000); // wait to have KRequestPending

   893 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   894 		ReqCompleted(aTsyReqHandle,KErrCancel);

   895 	else

   896 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   897 	return KErrNone;

   898 	}

   899 

   900 TInt CGprsContextDGprsTsy::RecoverCommPort(const TTsyReqHandle aTsyReqHandle)

   901 	{

   902 	LOGTEXT(_L8("CGprsContextDGprsTsy::RecoverCommPort called"));

   903 	User::After(300000); // wait to have KRequestPending

   904 	if(!iRecoverCommPort++)

   905 		ReqCompleted(aTsyReqHandle,KErrNone);

   906 	iTsyAsyncReqHandle = aTsyReqHandle;

   907 	return KErrNone;

   908 	}

   909 

   910 TInt CGprsContextDGprsTsy::RecoverCommPortCancel(const TTsyReqHandle aTsyReqHandle)	

   911 	{

   912 	LOGTEXT(_L8("CGprsContextDGprsTsy::RecoverCommPortCancel called"));

   913 	User::After(300000); // wait to have KRequestPending

   914 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   915 		ReqCompleted(aTsyReqHandle,KErrCancel);

   916 	else

   917 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   918 	return KErrNone;

   919 	}

   920 

   921 TInt CGprsContextDGprsTsy::GetStatus(const TTsyReqHandle aTsyReqHandle,RPacketContext::TContextStatus* aContextStatus)

   922 	{

   923 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetStatus called"));

   924 	User::After(300000); // wait to have KRequestPending

   925 	*aContextStatus = DPCKTTSY_CONTEXT_STATUS1;

   926 	ReqCompleted(aTsyReqHandle,KErrNone);

   927 	return KErrNone;

   928 	}

   929 

   930 TInt CGprsContextDGprsTsy::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle,RPacketContext::TContextStatus* aContextStatus)

   931 	{

   932 	User::After(300000); // wait to have KRequestPending

   933 	if (!iNotifyStatusChange++)

   934 		{

   935 		LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyStatusChange called"));

   936 		*aContextStatus = DPCKTTSY_CONTEXT_STATUS2;

   937 		ReqCompleted(aTsyReqHandle,KErrNone);

   938 		}

   939 	iTsyAsyncReqHandle = aTsyReqHandle;

   940 	return KErrNone;

   941 	}

   942 

   943 TInt CGprsContextDGprsTsy::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

   944 	{

   945 	LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyStatusChangeCancel called"));

   946 	User::After(300000); // wait to have KRequestPending

   947 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   948 		ReqCompleted(aTsyReqHandle,KErrCancel);

   949 	else

   950 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   951 	return KErrNone;

   952 	}

   953 

   954 TInt CGprsContextDGprsTsy::GetProfileName(const TTsyReqHandle aTsyReqHandle, TName* aQosProfile)

   955 	{

   956 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetProfileName called"));

   957 	User::After(300000); // wait to have KRequestPending

   958 	*aQosProfile = DPCKTTSY_PROFILE_NAME;

   959 	ReqCompleted(aTsyReqHandle, KErrNone);

   960 	return KErrNone;

   961 	}

   962 

   963 

   964 TInt CGprsContextDGprsTsy::GetDataVolumeTransferred(const TTsyReqHandle aTsyReqHandle, RPacketContext::TDataVolume* aVolume)

   965 /** 

   966  * GetDataVolumeTransferred method - Returns the volume of data transferred.

   967  * A synchronous and asynchronous variant of this method is now supported - Change 

   968  * Request: NDOE-58VF4Q. In the test code, the synchronous method is called first.

   969  * Note that the synchronous variant is deprecated.

   970  * In the switch statement, cases 0 and 1 implement the synchronous call, while cases 2 and 

   971  * 3 implement the asynchronous call.

   972  */

   973 	{

   974 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetDataVolumeTransferred called"));

   975 	

   976 //	User::After(300000); // wait to have KRequestPending

   977 	switch (iGetDataVolumeTransferred++)

   978 		{

   979 		case 0:

   980 		case 1:

   981 			aVolume->iBytesSent = DPCKTTSY_BYTES_SENT1;

   982 			aVolume->iOverflowCounterSent = DPCKTTSY_OVERFLOW_COUNTER_SENT1;

   983 			aVolume->iBytesReceived = DPCKTTSY_BYTES_RCVD1;

   984 			aVolume->iOverflowCounterReceived = DPCKTTSY_OVERFLOW_COUNTER_RCVD1;

   985 	

   986 			ReqCompleted(aTsyReqHandle,KErrNone);

   987 			break;

   988 		case 2:

   989 			aVolume->iBytesSent = DPCKTTSY_BYTES_SENT3;

   990 			aVolume->iOverflowCounterSent = DPCKTTSY_OVERFLOW_COUNTER_SENT3;

   991 			aVolume->iBytesReceived = DPCKTTSY_BYTES_RCVD3;

   992 			aVolume->iOverflowCounterReceived = DPCKTTSY_OVERFLOW_COUNTER_RCVD3;

   993 			ReqCompleted(aTsyReqHandle,KErrNone);

   994 		case 3:

   995 			iTsyAsyncReqHandle = aTsyReqHandle;

   996 			break;

   997 		default:

   998 			LOGTEXT(_L8("CGprsContextDGprsTsy::GetDataVolumeTransferred - Error in switch statement"));

   999 			break;

  1000 		} // switch

  1001 

  1002 	return KErrNone;

  1003 	}

  1004 

  1005 TInt CGprsContextDGprsTsy::GetDataVolumeTransferredCancel(const TTsyReqHandle aTsyReqHandle)

  1006 	{

  1007 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetDataVolumeTransferredCancel called"));

  1008 	User::After(300000); // wait to have KRequestPending

  1009 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1010 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1011 	else

  1012 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1013 	return KErrNone;

  1014 	}

  1015 

  1016 TInt CGprsContextDGprsTsy::GetConnectionSpeed(const TTsyReqHandle aTsyReqHandle,TUint* aRate)

  1017 	{

  1018 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetConnectionSpeed called"));

  1019 	User::After(300000); // wait to have KRequestPending

  1020 	*aRate = DPCKTTSY_CONNECTION_RATE;

  1021 	ReqCompleted(aTsyReqHandle,KErrNone);

  1022 	return KErrNone;

  1023 	}

  1024 

  1025 TInt CGprsContextDGprsTsy::NotifyConnectionSpeedChange(const TTsyReqHandle aTsyReqHandle, TUint* aRate)

  1026 	{

  1027 	User::After(300000); // wait to have KRequestPending

  1028 	if (!iNotifySpeedChange++)

  1029 		{

  1030 		LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyStatusChange called"));

  1031 			*aRate = DPCKTTSY_CONNECTION_RATE;

  1032 			ReqCompleted(aTsyReqHandle,KErrNone);

  1033 		}

  1034     	iTsyAsyncReqHandle = aTsyReqHandle;

  1035 		return KErrNone;

  1036 	}

  1037 

  1038 TInt CGprsContextDGprsTsy::NotifyConnectionSpeedChangeCancel(const TTsyReqHandle aTsyReqHandle)

  1039 	{

  1040 	LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyConnectionSpeedChangeCancel called"));

  1041 	User::After(300000); // wait to have KRequestPending

  1042 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1043 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1044 	else

  1045 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1046 	return KErrNone;

  1047 	}

  1048 

  1049 TInt CGprsContextDGprsTsy::NotifyDataTransferred(const TTsyReqHandle aTsyReqHandle, RPacketContext::TDataVolume* aVolume, RPacketContext::TNotifyDataTransferredRequest* aData)

  1050 	{

  1051 	User::After(300000); // wait to have KRequestPending

  1052 	if ((aData->iRcvdGranularity != DPCKTTSY_RCVD_GRANULARITY) ||

  1053 		(aData->iSentGranularity != DPCKTTSY_SENT_GRANULARITY))

  1054 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1055 	else

  1056 		{

  1057 		if (!iNotifyDataTransferred++)

  1058 			{

  1059 			LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyStatusChange called"));

  1060 			aVolume->iBytesSent = DPCKTTSY_BYTES_SENT2;

  1061 			aVolume->iOverflowCounterSent = DPCKTTSY_OVERFLOW_COUNTER_SENT2;

  1062 			aVolume->iBytesReceived = DPCKTTSY_BYTES_RCVD2;

  1063 			aVolume->iOverflowCounterReceived = DPCKTTSY_OVERFLOW_COUNTER_RCVD2;

  1064 			ReqCompleted(aTsyReqHandle,KErrNone);

  1065 			}

  1066 		iTsyAsyncReqHandle = aTsyReqHandle;

  1067 		}

  1068 	return KErrNone;

  1069 	}

  1070 

  1071 TInt CGprsContextDGprsTsy::NotifyDataTransferredCancel(const TTsyReqHandle aTsyReqHandle)

  1072 	{

  1073 	LOGTEXT(_L8("CGprsContextDGprsTsy::NotifyDataTransferredCancel called"));

  1074 	User::After(300000); // wait to have KRequestPending

  1075 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1076 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1077 	else

  1078 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1079 	return KErrNone;

  1080 	}

  1081 

  1082 TInt CGprsContextDGprsTsy::GetLastErrorCause(const TTsyReqHandle aTsyReqHandle,TInt* aError)

  1083 	{

  1084 	LOGTEXT(_L8("CGprsContextDGprsTsy::GetLastErrorCause called"));

  1085 	User::After(300000); // wait to have KRequestPending

  1086 	*aError = DPCKTTSY_LAST_ERROR_CAUSE;

  1087 	ReqCompleted(aTsyReqHandle,KErrNone);

  1088 	return KErrNone;

  1089 	}

  1090 

  1091 TInt CGprsContextDGprsTsy::InitialiseContext(const TTsyReqHandle aTsyReqHandle, TDes8* aDataChannel)

  1092 /**

  1093  * InitialiseContext method - Enables asynchronous resource reservation.

  1094  */

  1095 	{

  1096 	LOGTEXT(_L8("CGprsContextDGprsTsy::InitialiseContext called"));

  1097 

  1098 	User::After(300000); // wait to have KRequestPending

  1099 	RPacketContext::TDataChannelV2Pckg* dataChannelV2Pckg = (RPacketContext::TDataChannelV2Pckg*)aDataChannel;

  1100 	RPacketContext::TDataChannelV2& dataChannelV2 = (*dataChannelV2Pckg)();

  1101 

  1102 	if(!iInitialiseContext++)

  1103 		{

  1104 		dataChannelV2.iCsy = DPCKTTSY_CSY_ASYNC;

  1105 		dataChannelV2.iPort = DPCKTTSY_PORT_ASYNC;

  1106 		dataChannelV2.iChannelId = DPCKTTSY_CHANNEL_ID;

  1107 		ReqCompleted(aTsyReqHandle,KErrNone);

  1108 		}

  1109 	iTsyAsyncReqHandle = aTsyReqHandle;

  1110 

  1111 	return KErrNone;

  1112 	}

  1113 

  1114 TInt CGprsContextDGprsTsy::InitialiseContextCancel(const TTsyReqHandle aTsyReqHandle)

  1115 /**

  1116  * InitialiseContextCancel - Cancels an asynchronous InitialiseContext() request.

  1117  */

  1118 	{

  1119 	LOGTEXT(_L8("CGprsContextDGprsTsy::InitialiseContextCancel called"));

  1120 	User::After(300000); // wait to have KRequestPending

  1121 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1122 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1123 	else

  1124 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1125 	return KErrNone;

  1126 	}

  1127 

  1128 TInt CGprsContextDGprsTsy::EnumeratePacketFilters(const TTsyReqHandle aTsyReqHandle, TInt* aCount)

  1129 /** 

  1130  * EnumeratePacketFilters method - Sets the number of packet filters

  1131  */

  1132 	{

  1133 	LOGTEXT(_L8("CGprsContextDGprsTsy::EnumeratePacketFilters called"));

  1134 	

  1135 	User::After(300000); // wait to have KRequestPending