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

    15 

    16 #include "pckttsy.h"

    17 #include "testdef.h"

    18 #include "etelpckt.h"

    19 #include <et_clsvr.h>

    20 #include "dpcktlog.h"

    21 #include <pcktcs.h>

    22 

    23 #include "coretsy.h"

    24 

    25 

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

    27 //

    28 //	CGprsDGprsTsy

    29 //

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

    31 

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

    33 /**

    34  * NewL method - Standard 2 phase constructor.

    35  */

    36 	{

    37 	LOGTEXT(_L8("CGprsDGprsTsy: Entered NewL()"));

    38 

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

    40 	CleanupStack::PushL(subsession);

    41 	subsession->ConstructL();

    42 	CleanupStack::Pop();

    43 	return subsession;

    44 	}

    45 

    46 void CGprsDGprsTsy::Init()

    47 	{}

    48 

    49 CGprsDGprsTsy::CGprsDGprsTsy(CPhoneFactoryDummyBase* aFac)

    50 	:CSubSessionExtDummyBase(aFac),

    51 	iActiveRequestObjects(_FOFF(CGprsDGprsTsy::CActiveListNode,iNext))

    52 

    53 	{

    54 	}

    55 

    56 void CGprsDGprsTsy::ConstructL()

    57 /**

    58  * ConstructL method.

    59  */

    60 	{

    61 	LOGTEXT(_L8("CGprsDGprsTsy: Entered constructor"));

    62 	iMutex.CreateGlobal(KNullDesC, EOwnerProcess);

    63 	iGetMbmsMonitoredServices = new CArrayPtrFlat<CListReadAllAttempt>(1);

    64 	iList=CPcktMbmsMonitoredServiceList::NewL();

    65 	}

    66 

    67 CGprsDGprsTsy::~CGprsDGprsTsy()

    68 /**

    69  * Destructor.

    70  */

    71 	{

    72 	if(iGetMbmsMonitoredServices)

    73 		{

    74 		iGetMbmsMonitoredServices->ResetAndDestroy();

    75 		delete iGetMbmsMonitoredServices;

    76 		}

    77   	if(iList)

    78   		{

    79   		delete iList;

    80   		}

    81   	iMutex.Close();

    82 	LOGTEXT(_L8("CGprsDGprsTsy: Entered destructor"));

    83 	}

    84 

    85 CTelObject* CGprsDGprsTsy::OpenNewObjectByNameL(const TDesC& aName)

    86 /**

    87  * 	Only gprs context objects can be opened from gprs object(s).

    88  */

    89 	{

    90 	LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectByNameL()"));

    91 

    92 	if (aName.Compare(_L("GPRS_CONTEXT"))==KErrNone)

    93 		{

    94 		return reinterpret_cast<CTelObject*>(CGprsContextDGprsTsy::NewL(FacPtr()));

    95 		}

    96 	return NULL;

    97 	}

    98 

    99 CTelObject* CGprsDGprsTsy::OpenNewObjectL(TDes& aNewName)

   100 /**

   101  * A new context opened by a client will have its name allocated by the TSY.

   102  */

   103 	{

   104 	if(aNewName.Compare(KMBMSContextName) == KErrNone)

   105 		{

   106 		LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectL()"));

   107 		aNewName.AppendNum(++iMbmsContextObjectCount);

   108 		return CMbmsContextDMbmsTsy::NewL(this,FacPtr());

   109 		}

   110 	else

   111 		{

   112 		LOGTEXT(_L8("CGprsDGprsTsy: OpenNewObjectL()"));

   113 		aNewName.Append(_L("PACKET_CONTEXT"));

   114 		aNewName.AppendNum(++iGprsContextObjectCount);

   115 		return CGprsContextDGprsTsy::NewL(FacPtr());

   116 		}

   117 	}

   118 

   119 CTelObject::TReqMode CGprsDGprsTsy::ReqModeL(const TInt aIpc)

   120 /**

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

   122  * type of request it has.

   123  * The following are example request types for this dummy TSY. All TSYs do not need to 

   124  * have these request types but they have been given "sensible" values in this dummy TSY code.

   125  */

   126 	{

   127 	LOGTEXT(_L8("CGprsDGprsTsy: ReqModeL() method"));

   128 

   129 	CTelObject::TReqMode ret=0;

   130 	switch (aIpc)

   131 		{

   132 		case EPacketAttach:

   133 		case EPacketDetach:

   134 		case EPacketRejectActivationRequest:

   135 		case EPacketSetMSClass:

   136 		case EPacketSetAttachMode:

   137 		case EPacketSetDefaultContextParams:

   138 		case EPacketGetStatus:

   139 		case EPacketGetContextInfo:

   140 		case EPacketGetNtwkRegStatus:

   141 		case EPacketGetMSClass:

   142 		case EPacketGetStaticCaps:

   143 		case EPacketGetDynamicCaps:

   144 		case EPacketGetAttachMode:

   145 		case EPacketGetDefaultContextParams:

   146 		case EPacketEnumerateContexts:

   147 		case EPacketSetPrefBearer:

   148 		case EPacketGetPrefBearer:

   149 		case EPacketGetCurrentReleaseMode:

   150 		case EPacketEnumerateNifs:

   151 		case EPacketGetNifInfo:

   152 		case EPacketEnumerateContextsInNif:

   153 		case EPacketGetContextNameInNif:

   154 		case EPacketPrepareOpenSecondary:

   155 		case EPacketDeactivateNIF:

   156 		case EPacketGetMbmsNetworkServiceStatus:

   157 		case EPacketUpdateMbmsMonitorServiceList:

   158 		case EPacketGetMbmsMonitoredServicesPhase1:

   159 		case EPacketGetMbmsMonitoredServicesPhase2:

   160 		case EPacketEnumerateMbmsMonitorServiceList:

   161 		case EPacketEnumerateMbmsActiveServiceList:

   162 			break;

   163 

   164 		case EPacketNotifyContextAdded:

   165 		case EPacketNotifyContextAddedCancel:

   166 		case EPacketNotifyStatusChange:

   167 		case EPacketNotifyContextActivationRequested:

   168 		case EPacketNotifyChangeOfNtwkRegStatus:

   169 		case EPacketNotifyMSClassChange:

   170 		case EPacketNotifyDynamicCapsChange:

   171 		case EPacketNotifyReleaseModeChange:

   172 		case EPacketNotifyAttachModeChange:

   173 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   174 		case EPacketNotifyMbmsServiceAvailabilityChange:

   175 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   176 			break;

   177 	

   178 		default:

   179 			User::Leave(KErrNotSupported);

   180 			break;

   181 		}

   182 	return ret;

   183 	}

   184 

   185 TInt CGprsDGprsTsy::RegisterNotification(const TInt aIpc)

   186 /**

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

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

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

   190  * receive from the phone.

   191  */

   192 	{

   193 	switch (aIpc)

   194 		{

   195 		case EPacketNotifyContextAdded:

   196 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Context added"));

   197 			return KErrNone;

   198 		case EPacketNotifyStatusChange:

   199 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Gprs status change"));

   200 			return KErrNone;

   201 		case EPacketNotifyContextActivationRequested:

   202 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Context activation requested"));

   203 			return KErrNone;

   204 		case EPacketNotifyChangeOfNtwkRegStatus:

   205 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network registration status change"));

   206 			return KErrNone;

   207 		case EPacketNotifyMSClassChange:

   208 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - MS class change"));

   209 			return KErrNone;

   210 		case EPacketNotifyDynamicCapsChange:

   211 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Dynamic capabilities change"));

   212 			return KErrNone;

   213 		case EPacketNotifyReleaseModeChange:

   214 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Release mode change"));

   215 			return KErrNone;

   216 		case EPacketNotifyAttachModeChange:

   217 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network attach mode change"));

   218 			return KErrNone;

   219 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   220 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Mbms Service Status change"));

   221 			return KErrNone;

   222 		case EPacketNotifyMbmsServiceAvailabilityChange:

   223 			LOGTEXT(_L8("CGprsDGprsTsy: RegisterNotification - Network Mbms Service change"));

   224 			return KErrNone;

   225 		default:

   226 			// Unknown or invalid IPC

   227 			LOGTEXT(_L8("CGprsDGprsTsy: Register error, unknown IPC"));

   228 			return KErrNotSupported;

   229 		}

   230 	}

   231 

   232 TInt CGprsDGprsTsy::DeregisterNotification(const TInt aIpc)

   233 /**

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

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

   236  * object has just closed the handle.

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

   238  * receive from the phone.

   239  */

   240 	{

   241 	switch (aIpc)

   242 		{

   243 		case EPacketNotifyContextAdded:

   244 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Context added"));

   245 			return KErrNone;

   246 		case EPacketNotifyStatusChange:

   247 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Gprs status change"));

   248 			return KErrNone;

   249 		case EPacketNotifyContextActivationRequested:

   250 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Context activation requested"));

   251 			return KErrNone;

   252 		case EPacketNotifyChangeOfNtwkRegStatus:

   253 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network registration status change"));

   254 			return KErrNone;

   255 		case EPacketNotifyMSClassChange:

   256 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - MS class change"));

   257 			return KErrNone;

   258 		case EPacketNotifyDynamicCapsChange:

   259 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Dynamic capabilities change"));

   260 			return KErrNone;

   261 		case EPacketNotifyReleaseModeChange:

   262 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network release mode change"));

   263 			return KErrNone;

   264 		case EPacketNotifyAttachModeChange:

   265 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network attach mode change"));

   266 			return KErrNone;

   267 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   268 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network Mbms Service Status change"));

   269 			return KErrNone;

   270 		case EPacketNotifyMbmsServiceAvailabilityChange:

   271 			LOGTEXT(_L8("CGprsDGprsTsy: DeregisterNotification - Network Mbms Service change"));

   272 			return KErrNone;

   273 		default:

   274 			// Unknown or invalid IPC

   275 			LOGTEXT(_L8("CGprsDGprsTsy: Deregister error, unknown IPC"));

   276 			return KErrNotSupported;

   277 		}

   278 	}

   279 

   280 TInt CGprsDGprsTsy::NumberOfSlotsL(const TInt aIpc)

   281 /**

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

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

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

   285  */

   286 	{

   287 	TInt numberOfSlots=1;

   288 	switch (aIpc)

   289 		{

   290 		case EPacketNotifyStatusChange:

   291 		case EPacketNotifyDynamicCapsChange:

   292 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   293 			LOGTEXT(_L8("CGprsDGprsTsy: Registered with 10 slots"));

   294 			numberOfSlots=10;

   295 			break;

   296 		case EPacketNotifyContextAdded:

   297 		case EPacketNotifyContextActivationRequested:

   298 		case EPacketNotifyChangeOfNtwkRegStatus:

   299 		case EPacketNotifyMSClassChange:

   300 		case EPacketNotifyReleaseModeChange:

   301 		case EPacketNotifyAttachModeChange:

   302 		case EPacketNotifyMbmsServiceAvailabilityChange:

   303 			LOGTEXT(_L8("CGprsDGprsTsy: Registered with 2 slots"));

   304 			numberOfSlots=2;

   305 			break;

   306 		default:

   307 			// Unknown or invalid IPC

   308 			LOGTEXT(_L8("CGprsDGprsTsy: Number of Slots error, unknown IPC"));

   309 			User::Leave(KErrNotSupported);

   310 			break;

   311 		}  

   312 	return numberOfSlots;

   313 	}

   314 

   315 

   316 TInt CGprsDGprsTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

   317 							  const TDataPackage& aPackage)

   318 /**

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

   320  * for the TSY to process.

   321  * A request handle, request type and request data are passed to the TSY.

   322  */

   323 	{

   324 	LOGTEXT(_L8("CGprsDGprsTsy: ExtFunc() method"));

   325 

   326 	TAny* dataPtr=aPackage.Ptr1();

   327 	TAny* dataPtr2=aPackage.Ptr2();

   328 

   329 	switch (aIpc)

   330 		{

   331 		case EPacketNotifyContextAdded:

   332 			return NotifyContextAdded(aTsyReqHandle, aPackage.Des1u());

   333 		case EPacketGetStatus:

   334 			return GetStatus(aTsyReqHandle,

   335 			REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

   336 		case EPacketNotifyStatusChange:

   337 			return NotifyStatusChange(aTsyReqHandle,

   338 			REINTERPRET_CAST(RPacketService::TStatus*, dataPtr));

   339 		case EPacketNotifyContextActivationRequested:

   340 			return NotifyContextActivationRequested(aTsyReqHandle,

   341 				REINTERPRET_CAST(TPacketDataConfigBase*, dataPtr));

   342 		case EPacketEnumerateContexts:

   343 			return EnumerateContexts(aTsyReqHandle,

   344 			REINTERPRET_CAST(TInt*, dataPtr),

   345 			REINTERPRET_CAST(TInt*, dataPtr2));

   346 		case EPacketGetContextInfo:

   347 			return GetContextInfo(aTsyReqHandle,

   348 			REINTERPRET_CAST(TInt*, dataPtr),

   349 			REINTERPRET_CAST(RPacketService::TContextInfo*, dataPtr2));

   350 		case EPacketGetNtwkRegStatus:

   351 			return GetNtwkRegStatus(aTsyReqHandle,

   352 			REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

   353 		case EPacketNotifyChangeOfNtwkRegStatus:

   354 			return NotifyChangeOfNtwkRegStatus(aTsyReqHandle,

   355 			REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr));

   356 		case EPacketGetMSClass:

   357 			return GetMSClass(aTsyReqHandle,

   358 			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr),

   359 			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr2));

   360 		case EPacketSetMSClass:

   361 			return SetMSClass(aTsyReqHandle,

   362 			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

   363 		case EPacketNotifyMSClassChange:

   364 			return NotifyMSClassChange(aTsyReqHandle,

   365 			REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr));

   366 		case EPacketGetStaticCaps:

   367 			return GetStaticCaps(aTsyReqHandle, 

   368 				REINTERPRET_CAST(TUint*, dataPtr),

   369 				REINTERPRET_CAST(RPacketContext::TProtocolType*, dataPtr2));

   370 		case EPacketGetDynamicCaps:

   371 			return GetDynamicCaps(aTsyReqHandle,

   372 			REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

   373 		case EPacketNotifyDynamicCapsChange:

   374 			return NotifyDynamicCapsChange(aTsyReqHandle,

   375 			REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr));

   376 		case EPacketSetAttachMode:

   377 			return SetAttachMode(aTsyReqHandle,

   378 			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

   379 		case EPacketGetAttachMode:

   380 			return GetAttachMode(aTsyReqHandle,

   381 			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

   382 		case EPacketNotifyAttachModeChange:

   383 			return NotifyAttachModeChange(aTsyReqHandle,

   384 			REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr));

   385 		case EPacketNotifyContextAddedCancel:

   386 			return NotifyContextAddedCancel(aTsyReqHandle);

   387 		case EPacketAttach:

   388 			return Attach(aTsyReqHandle);

   389 		case EPacketAttachCancel:

   390 			return AttachCancel(aTsyReqHandle);

   391 		case EPacketDetach:

   392 			return Detach(aTsyReqHandle);

   393 		case EPacketDetachCancel:

   394 			return DetachCancel(aTsyReqHandle);

   395 		case EPacketNotifyStatusChangeCancel:

   396 			return NotifyStatusChangeCancel(aTsyReqHandle);

   397 		case EPacketNotifyContextActivationRequestedCancel:

   398 			return NotifyContextActivationRequestedCancel(aTsyReqHandle);

   399 		case EPacketRejectActivationRequest:

   400 			return RejectActivationRequest(aTsyReqHandle);

   401 		case EPacketRejectActivationRequestCancel:

   402 			return RejectActivationRequestCancel(aTsyReqHandle);

   403 		case EPacketGetContextInfoCancel:

   404 			return GetContextInfoCancel(aTsyReqHandle);

   405 		case EPacketNotifyChangeOfNtwkRegStatusCancel:

   406 			return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle);

   407 		case EPacketGetMSClassCancel:

   408 			return GetMSClassCancel(aTsyReqHandle);

   409 		case EPacketSetMSClassCancel:

   410 			return SetMSClassCancel(aTsyReqHandle);

   411 		case EPacketNotifyMSClassChangeCancel:

   412 			return NotifyMSClassChangeCancel(aTsyReqHandle);

   413 		case EPacketSetPrefBearer:

   414 			return SetPreferredBearer(aTsyReqHandle, 

   415 				REINTERPRET_CAST(RPacketService::TPreferredBearer*, dataPtr));

   416 		case EPacketGetPrefBearer:

   417 			return GetPreferredBearer(aTsyReqHandle,

   418 				REINTERPRET_CAST(RPacketService::TPreferredBearer*, dataPtr));

   419 		case EPacketNotifyDynamicCapsChangeCancel:

   420 			return NotifyDynamicCapsChangeCancel(aTsyReqHandle);

   421 		case EPacketSetDefaultContextParams:

   422 			return SetDefaultContextParams(aTsyReqHandle, aPackage.Des1n());

   423 		case EPacketGetDefaultContextParams:

   424 			return GetDefaultContextParams(aTsyReqHandle, aPackage.Des1n());

   425 		case EPacketGetCurrentReleaseMode:

   426 			return GetCurrentReleaseMode(aTsyReqHandle,

   427 				REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr));

   428 		case EPacketNotifyReleaseModeChange:

   429 			return NotifyReleaseModeChange(aTsyReqHandle,

   430 			REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr));

   431 		case EPacketEnumerateNifs:

   432 			return EnumerateNifs(aTsyReqHandle,

   433 				REINTERPRET_CAST(TInt*, dataPtr));

   434 		case EPacketEnumerateNifsCancel:

   435 			return EnumerateNifsCancel(aTsyReqHandle);

   436 		case EPacketGetNifInfo:

   437 			return GetNifInfo(aTsyReqHandle,

   438 				REINTERPRET_CAST(TInt*, dataPtr),

   439 				aPackage.Des2n());

   440 		case EPacketGetNifInfoCancel:

   441 			return GetNifInfoCancel(aTsyReqHandle);	

   442 		case EPacketEnumerateContextsInNif:

   443 			return EnumerateContextsInNif(aTsyReqHandle,

   444 				aPackage.Des2u(),

   445 				REINTERPRET_CAST(TInt*, dataPtr));

   446 		case EPacketEnumerateContextsInNifCancel:

   447 			return EnumerateContextsInNifCancel(aTsyReqHandle);

   448 		case EPacketGetContextNameInNif:

   449 			return GetContextNameInNif(aTsyReqHandle,

   450 				REINTERPRET_CAST(RPacketService::TContextNameInNif*, dataPtr),

   451 				aPackage.Des2u());

   452 		case EPacketGetContextNameInNifCancel:

   453 			return GetContextNameInNifCancel(aTsyReqHandle);

   454 		case EPacketPrepareOpenSecondary:

   455 			return PrepareOpenSecondary(aTsyReqHandle, aPackage.Des1u());

   456 		case EPacketDeactivateNIF:

   457 			return DeactivateNIF(aTsyReqHandle, REINTERPRET_CAST(TDesC*,dataPtr));

   458 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   459 			return NotifyMbmsNetworkServiceStatusChange(aTsyReqHandle,

   460 			reinterpret_cast<TMbmsNetworkServiceStatus*>(dataPtr));

   461 		case EPacketGetMbmsNetworkServiceStatus:

   462 			return GetMbmsNetworkServiceStatus(aTsyReqHandle,

   463 			reinterpret_cast<TBool*>(dataPtr),

   464 			reinterpret_cast<TMbmsNetworkServiceStatus*>(dataPtr2));

   465 		case EPacketNotifyMbmsServiceAvailabilityChange:

   466 			return NotifyMbmsServiceAvailabilityChange(aTsyReqHandle);

   467 		case EPacketUpdateMbmsMonitorServiceList:

   468 			if(dataPtr2)

   469 				{

   470 				return UpdateMbmsMonitorServiceListL(aTsyReqHandle,

   471 				reinterpret_cast<TMbmsAction*>(dataPtr),aPackage.Des2n());	

   472 				}

   473 			else

   474 				{

   475 				return UpdateMbmsMonitorServiceListL(aTsyReqHandle,

   476 				reinterpret_cast<TMbmsAction*>(dataPtr));

   477 				}

   478 		case EPacketGetMbmsMonitoredServicesPhase1:

   479 			return GetMbmsMonitoredServicesPhase1(aTsyReqHandle, 

   480 			reinterpret_cast<TClientId*>(dataPtr), 

   481 			reinterpret_cast<TUint*>(dataPtr2));

   482 		case EPacketGetMbmsMonitoredServicesPhase2:

   483 			return GetMbmsMonitoredServicesPhase2(aTsyReqHandle, 

   484 			reinterpret_cast<TClientId*>(dataPtr),aPackage.Des2n());

   485 		case EPacketEnumerateMbmsMonitorServiceList:

   486 			return EnumerateMbmsMonitorServiceList(aTsyReqHandle, 

   487 			reinterpret_cast<TInt*>(dataPtr),

   488 			reinterpret_cast<TInt*>(dataPtr2));

   489 		case EPacketEnumerateMbmsActiveServiceList:

   490 			return EnumerateMbmsActiveServiceList(aTsyReqHandle, 

   491 			reinterpret_cast<TInt*>(dataPtr),

   492 			reinterpret_cast<TInt*>(dataPtr2));

   493 		default:

   494 			return KErrNotSupported;

   495 		}

   496 	}

   497 

   498 TInt CGprsDGprsTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   499 /**

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

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

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

   503  * asynchronous requests.

   504  */

   505 	{

   506 	LOGTEXT(_L8("CGprsDGprsTsy: - CancelService called"));

   507 	switch (aIpc)

   508 		{

   509 		case EPacketNotifyContextAdded:

   510 			return NotifyContextAddedCancel(aTsyReqHandle);

   511 		case EPacketAttach:

   512 			return AttachCancel(aTsyReqHandle);

   513 		case EPacketDetach:

   514 			return DetachCancel(aTsyReqHandle);

   515 		case EPacketNotifyStatusChange:

   516 			return NotifyStatusChangeCancel(aTsyReqHandle);

   517 		case EPacketNotifyContextActivationRequested:

   518 			return NotifyContextActivationRequestedCancel(aTsyReqHandle);

   519 		case EPacketRejectActivationRequest:

   520 			return RejectActivationRequestCancel(aTsyReqHandle);

   521 		case EPacketGetContextInfo:

   522 			return GetContextInfoCancel(aTsyReqHandle);

   523 		case EPacketNotifyChangeOfNtwkRegStatus:

   524 			return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle);

   525 		case EPacketGetMSClass:

   526 			return GetMSClassCancel(aTsyReqHandle);

   527 		case EPacketSetMSClass:

   528 			return SetMSClassCancel(aTsyReqHandle);

   529 		case EPacketNotifyMSClassChange:

   530 			return NotifyMSClassChangeCancel(aTsyReqHandle);

   531 		case EPacketNotifyDynamicCapsChange:

   532 			return NotifyDynamicCapsChangeCancel(aTsyReqHandle);

   533 		case EPacketSetPrefBearer:

   534 			return SetPreferredBearerCancel(aTsyReqHandle);

   535 		case EPacketGetPrefBearer:

   536 			return GetPreferredBearerCancel(aTsyReqHandle);

   537 		case EPacketSetAttachMode:

   538 			return SetAttachModeCancel(aTsyReqHandle);

   539 		case EPacketGetAttachMode:

   540 			return GetAttachModeCancel(aTsyReqHandle);

   541 		case EPacketNotifyAttachModeChange:

   542 			return NotifyAttachModeChangeCancel(aTsyReqHandle);

   543 		case EPacketSetDefaultContextParams:

   544 			return SetDefaultContextParamsCancel(aTsyReqHandle);

   545 		case EPacketGetDefaultContextParams:

   546 			return GetDefaultContextParamsCancel(aTsyReqHandle);

   547 		case EPacketGetCurrentReleaseMode:

   548 			return GetCurrentReleaseModeCancel(aTsyReqHandle);

   549 		case EPacketNotifyReleaseModeChange:

   550 			return NotifyReleaseModeChangeCancel(aTsyReqHandle);

   551 		case EPacketEnumerateNifs:

   552 			return EnumerateNifsCancel(aTsyReqHandle);

   553 		case EPacketGetNifInfo:

   554 			return GetNifInfoCancel(aTsyReqHandle);

   555 		case EPacketEnumerateContextsInNif:

   556 			return EnumerateContextsInNifCancel(aTsyReqHandle);

   557 		case EPacketGetContextNameInNif:

   558 			return GetContextNameInNifCancel(aTsyReqHandle);

   559 		case EPacketDeactivateNIF:

   560 			return DeactivateNIFCancel(aTsyReqHandle);

   561 		case EPacketNotifyMbmsNetworkServiceStatusChange:

   562 			return NotifyMbmsNetworkServiceStatusChangeCancel(aTsyReqHandle);

   563 		case EPacketGetMbmsNetworkServiceStatus:

   564 			return GetMbmsNetworkServiceStatusCancel(aTsyReqHandle);

   565 		case EPacketNotifyMbmsServiceAvailabilityChange:

   566 			return NotifyMbmsServiceAvailabilityChangeCancel(aTsyReqHandle);

   567 		case EPacketUpdateMbmsMonitorServiceList:

   568 			return UpdateMbmsMonitorServiceListCancel(aTsyReqHandle);

   569 		case EPacketGetMbmsMonitoredServicesPhase1:

   570 		case EPacketGetMbmsMonitoredServicesPhase2:

   571 			return GetMbmsMonitoredServicesCancel(aTsyReqHandle);

   572 		case EPacketEnumerateMbmsMonitorServiceList:

   573 			return EnumerateMbmsMonitorServiceListCancel(aTsyReqHandle);

   574 		case EPacketEnumerateMbmsActiveServiceList:

   575 			return EnumerateMbmsActiveServiceListCancel(aTsyReqHandle);

   576 		default:

   577 			return KErrGeneral; 

   578 		} 

   579 	}

   580 

   581 

   582 /***********************************************************************************/

   583 //

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

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

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

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

   588 //

   589 /***********************************************************************************/

   590 TInt CGprsDGprsTsy::NotifyContextAdded(const TTsyReqHandle aTsyReqHandle, TDes* aContextId)

   591 	{

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

   593 	if (!iNotifyContextAdded++)

   594 		{

   595 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextAdded called"));

   596 		*aContextId = DPCKTTSY_CONTEXT_ID;

   597 		ReqCompleted(aTsyReqHandle,KErrNone);

   598 		}

   599 	iTsyAsyncReqHandle = aTsyReqHandle;

   600 	return KErrNone;

   601 	}

   602 

   603 TInt CGprsDGprsTsy::NotifyContextAddedCancel(const TTsyReqHandle aTsyReqHandle)

   604 	{

   605 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextAddedCancel called"));

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

   607 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   608 		ReqCompleted(aTsyReqHandle,KErrCancel);

   609 	else

   610 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   611 	return KErrNone;

   612 	}

   613 

   614 TInt CGprsDGprsTsy::Attach(const TTsyReqHandle aTsyReqHandle)

   615 	{

   616 	LOGTEXT(_L8("CGprsDGprsTsy::Attach called"));

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

   618 	if(!iAttach++)

   619 		ReqCompleted(aTsyReqHandle,KErrNone);

   620 	iTsyAsyncReqHandle = aTsyReqHandle;

   621 	return KErrNone;

   622 	}

   623 

   624 TInt CGprsDGprsTsy::AttachCancel(const TTsyReqHandle aTsyReqHandle)

   625 	{

   626 	LOGTEXT(_L8("CGprsDGprsTsy::AttachCancel called"));

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

   628 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   629 		ReqCompleted(aTsyReqHandle,KErrCancel);

   630 	else

   631 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   632 	return KErrNone;

   633 	}

   634 

   635 TInt CGprsDGprsTsy::Detach(const TTsyReqHandle aTsyReqHandle)

   636 	{

   637 	LOGTEXT(_L8("CGprsDGprsTsy::Detach called"));

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

   639 	if(!iDetach++)

   640 		ReqCompleted(aTsyReqHandle,KErrNone);

   641 	iTsyAsyncReqHandle = aTsyReqHandle;

   642 	return KErrNone;

   643 	}

   644 

   645 TInt CGprsDGprsTsy::DetachCancel(const TTsyReqHandle aTsyReqHandle)

   646 	{

   647 	LOGTEXT(_L8("CGprsDGprsTsy:: called"));

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

   649 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   650 		ReqCompleted(aTsyReqHandle,KErrCancel);

   651 	else

   652 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   653 	return KErrNone;

   654 	}

   655 

   656 TInt CGprsDGprsTsy::GetStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aGprsStatus)

   657 	{

   658 	LOGTEXT(_L8("CGprsDGprsTsy::DetachCancel called"));

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

   660 	*aGprsStatus = DPCKTTSY_PACKET_STATUS1;

   661 	ReqCompleted(aTsyReqHandle,KErrNone);

   662 	return KErrNone;

   663 	}

   664 

   665 TInt CGprsDGprsTsy::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aGprsStatus)

   666 	{

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

   668 	if (!iNotifyStatusChange++)

   669 		{

   670 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyStatusChange called"));

   671 		*aGprsStatus = DPCKTTSY_PACKET_STATUS2;

   672 		ReqCompleted(aTsyReqHandle,KErrNone);

   673 		}

   674 	iTsyAsyncReqHandle = aTsyReqHandle;

   675 	return KErrNone;

   676 	}

   677 

   678 TInt CGprsDGprsTsy::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

   679 	{

   680 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyStatusChangeCancel called"));

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

   682 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   683 		ReqCompleted(aTsyReqHandle,KErrCancel);

   684 	else

   685 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   686 	return KErrNone;

   687 	}

   688 

   689 TInt CGprsDGprsTsy::NotifyContextActivationRequested(const TTsyReqHandle aTsyReqHandle, TPacketDataConfigBase* aConfig)

   690 	{

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

   692 	if (!iNotifyContextActivationRequested++)

   693 		{

   694 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextActivationRequested called"));

   695 		

   696 		if (aConfig->ExtensionId() == TPacketDataConfigBase::KConfigGPRS)

   697 			{

   698 			RPacketContext::TContextConfigGPRS* aGprsConfig = (RPacketContext::TContextConfigGPRS*) aConfig;

   699 			aGprsConfig->iPdpType = DPCKTTSY_PDP_TYPE1;

   700 			aGprsConfig->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   701 			aGprsConfig->iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   702 			aGprsConfig->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   703 			aGprsConfig->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   704 			aGprsConfig->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   705 			aGprsConfig->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   706 			aGprsConfig->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   707 			ReqCompleted(aTsyReqHandle,KErrNone);

   708 			}

   709 		else if (aConfig->ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4)

   710 			{

   711 			RPacketContext::TContextConfigR99_R4* aR99Config = (RPacketContext::TContextConfigR99_R4*) aConfig;

   712 			aR99Config->iPdpType = DPCKTTSY_PDP_TYPE1;

   713 			aR99Config->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   714 			aR99Config->iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   715 			aR99Config->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   716 			aR99Config->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   717 			aR99Config->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   718 			aR99Config->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   719 			aR99Config->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   720 			aR99Config->iPFI = DPCKTTSY_PFICONTEXT_SIG;

   721 			ReqCompleted(aTsyReqHandle,KErrNone);

   722 			}

   723 		else if (aConfig->ExtensionId()==TPacketDataConfigBase::KConfigRel5)

   724 			{

   725 			RPacketContext::TContextConfig_R5* aR5Config = (RPacketContext::TContextConfig_R5*) aConfig;

   726 			aR5Config->iPdpType = DPCKTTSY_PDP_TYPE1;

   727 			aR5Config->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;

   728 			aR5Config->iAccessPointName = DPCKTTSY_ACCESS_POINT1;

   729 			aR5Config->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;

   730 			aR5Config->iProtocolConfigOption.iAuthInfo.iUsername = DPCKTTSY_USER_NAME1;

   731 			aR5Config->iProtocolConfigOption.iAuthInfo.iPassword = DPCKTTSY_PASSWORD1;

   732 			aR5Config->iProtocolConfigOption.iAuthInfo.iProtocol = DPCKTTSY_PROTOCOL_TYPE1_0;

   733 			aR5Config->iNWIContext = DPCKTTSY_NWICONTEXT_TRUE;

   734 			aR5Config->iPFI = DPCKTTSY_PFICONTEXT_SIG;

   735 			aR5Config->iPdpDataCompression = DPCKTTSY_DATACOMPRESSION_EV42;

   736 			aR5Config->iPdpHeaderCompression = DPCKTTSY_HEADERCOMPRESSION_ERFC1144;

   737 			ReqCompleted(aTsyReqHandle,KErrNone);

   738 			}

   739 		else

   740 			ReqCompleted(aTsyReqHandle, KErrNotSupported);

   741 		}

   742 	iTsyAsyncReqHandle = aTsyReqHandle;

   743 	return KErrNone;

   744 	}

   745 

   746 TInt CGprsDGprsTsy::NotifyContextActivationRequestedCancel(const TTsyReqHandle aTsyReqHandle)

   747 	{

   748 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyContextActivationRequestedCancel called"));

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

   750 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   751 		ReqCompleted(aTsyReqHandle,KErrCancel);

   752 	else

   753 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   754 	return KErrNone;

   755 	}

   756 

   757 TInt CGprsDGprsTsy::RejectActivationRequest(const TTsyReqHandle aTsyReqHandle)

   758 	{

   759 	LOGTEXT(_L8("CGprsDGprsTsy::RejectActivationRequest called"));

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

   761 	if(!iRejectActivationRequest++)

   762 		ReqCompleted(aTsyReqHandle,KErrNone);

   763 	iTsyAsyncReqHandle = aTsyReqHandle;

   764 	return KErrNone;

   765 	}

   766 

   767 TInt CGprsDGprsTsy::RejectActivationRequestCancel(const TTsyReqHandle aTsyReqHandle)

   768 	{

   769 	LOGTEXT(_L8("CGprsDGprsTsy::RejectActivationRequestCancel called"));

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

   771 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   772 		ReqCompleted(aTsyReqHandle,KErrCancel);

   773 	else

   774 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   775 	return KErrNone;

   776 	}

   777 

   778 TInt CGprsDGprsTsy::EnumerateContexts(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed)

   779 	{

   780 	LOGTEXT(_L8("CGprsDGprsTsy::EnumerateContexts called"));

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

   782 	*aCount = DPCKTTSY_NUMBER_OF_CONTEXTS;

   783 	*aMaxAllowed = DPCKTTSY_MAX_NUMBER_OF_CONTEXTS;

   784 	ReqCompleted(aTsyReqHandle,KErrNone);

   785 	return KErrNone;

   786 	}

   787 

   788 TInt CGprsDGprsTsy::GetContextInfo(const TTsyReqHandle aTsyReqHandle, TInt* aIndex,RPacketService::TContextInfo* aInfo)

   789 	{

   790 	LOGTEXT(_L8("CGprsDGprsTsy::GetContextInfo called"));

   791 

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

   793 	switch (*aIndex)

   794 		{

   795 		case 0:

   796 			if(!iGetContextInfo++)

   797 				{

   798 				aInfo->iName=DPCKTTSY_CONTEXT_INFO_NAME0;

   799 				aInfo->iStatus=DPCKTTSY_CONTEXT_INFO_STATUS0;

   800 				ReqCompleted(aTsyReqHandle,KErrNone);

   801 				}

   802 			break;

   803 		case 1:

   804 			aInfo->iName=DPCKTTSY_CONTEXT_INFO_NAME1;

   805 			aInfo->iStatus=DPCKTTSY_CONTEXT_INFO_STATUS1;

   806 			ReqCompleted(aTsyReqHandle,KErrNone);

   807 			break;

   808 		default:

   809 			ReqCompleted(aTsyReqHandle,KErrCorrupt);

   810 			break;

   811 		}

   812 	iTsyAsyncReqHandle = aTsyReqHandle;

   813 	return KErrNone;

   814 	}

   815 

   816 TInt CGprsDGprsTsy::GetContextInfoCancel(const TTsyReqHandle aTsyReqHandle) 

   817 	{

   818 	LOGTEXT(_L8("CGprsDGprsTsy::GetContextInfoCancel called"));

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

   820 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   821 		ReqCompleted(aTsyReqHandle,KErrCancel);

   822 	else

   823 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   824 	return KErrNone;

   825 	}

   826 

   827 TInt CGprsDGprsTsy::GetNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus)

   828 	{

   829 	LOGTEXT(_L8("CGprsDGprsTsy::GetNtwkRegStatus called"));

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

   831 	*aRegistrationStatus = DPCKTTSY_REGISTRATION_STATUS1;

   832 	ReqCompleted(aTsyReqHandle,KErrNone);

   833 	return KErrNone;

   834 	}

   835 

   836 TInt CGprsDGprsTsy::NotifyChangeOfNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus)

   837 	{

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

   839 	if (!iNotifyChangeOfNtwkRegStatus++)

   840 		{

   841 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyChangeOfNtwkRegStatus called"));

   842 		*aRegistrationStatus = DPCKTTSY_REGISTRATION_STATUS2;

   843 		ReqCompleted(aTsyReqHandle,KErrNone);

   844 		}

   845 	iTsyAsyncReqHandle = aTsyReqHandle;

   846 	return KErrNone;

   847 	}

   848 

   849 TInt CGprsDGprsTsy::NotifyChangeOfNtwkRegStatusCancel(const TTsyReqHandle aTsyReqHandle)

   850 	{

   851 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyChangeOfNtwkRegStatusCancel called"));

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

   853 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   854 		ReqCompleted(aTsyReqHandle,KErrCancel);

   855 	else

   856 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   857 	return KErrNone;

   858 	}

   859 

   860 TInt CGprsDGprsTsy::GetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aCurrentClass, RPacketService::TMSClass* aMaxClass)

   861 	{

   862 	LOGTEXT(_L8("CGprsDGprsTsy:: GetMSClass called"));

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

   864 	if(!iGetMSClass++)

   865 		{

   866 		*aCurrentClass=DPCKTTSY_CURRENT_MS_CLASS;

   867 		*aMaxClass=DPCKTTSY_MAX_MS_CLASS;

   868 		ReqCompleted(aTsyReqHandle,KErrNone);

   869 		}

   870 	iTsyAsyncReqHandle = aTsyReqHandle;

   871 	return KErrNone;

   872 	}

   873 

   874 TInt CGprsDGprsTsy::GetMSClassCancel(const TTsyReqHandle aTsyReqHandle)

   875 	{

   876 	LOGTEXT(_L8("CGprsDGprsTsy::GetMSClass called"));

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

   878 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   879 		ReqCompleted(aTsyReqHandle,KErrCancel);

   880 	else

   881 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   882 	return KErrNone;

   883 	}

   884 

   885 TInt CGprsDGprsTsy::SetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aClass)

   886 	{

   887 	LOGTEXT(_L8("CGprsDGprsTsy::SetMSClass called"));

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

   889 	if (*aClass!=DPCKTTSY_SET_MS_CLASS) 

   890 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   891 	else

   892 		{

   893 		if(!iSetMSClass++)

   894 			ReqCompleted(aTsyReqHandle,KErrNone);

   895 		iTsyAsyncReqHandle = aTsyReqHandle;

   896 		}

   897 	return KErrNone;

   898 	}

   899 

   900 TInt CGprsDGprsTsy::SetMSClassCancel(const TTsyReqHandle aTsyReqHandle)

   901 	{

   902 	LOGTEXT(_L8("CGprsDGprsTsy::SetMSClassCancel called"));

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

   904 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   905 		ReqCompleted(aTsyReqHandle,KErrCancel);

   906 	else

   907 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   908 	return KErrNone;

   909 	}

   910 

   911 TInt CGprsDGprsTsy::NotifyMSClassChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aNewClass)

   912 	{

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

   914 	if (!iNotifyMSClassChange++)

   915 		{

   916 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyMSClassChange called"));

   917 		*aNewClass = DPCKTTSY_NEW_MS_CLASS;

   918 		ReqCompleted(aTsyReqHandle,KErrNone);

   919 		}

   920 	iTsyAsyncReqHandle = aTsyReqHandle;

   921 	return KErrNone;

   922 	}

   923 

   924 TInt CGprsDGprsTsy::NotifyMSClassChangeCancel(const TTsyReqHandle aTsyReqHandle)

   925 	{

   926 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyMSClassChangeCancel called"));

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

   928 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   929 		ReqCompleted(aTsyReqHandle,KErrCancel);

   930 	else

   931 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   932 	return KErrNone;

   933 	}

   934 

   935 TInt CGprsDGprsTsy::GetStaticCaps(const TTsyReqHandle aTsyReqHandle, TUint* aCaps,RPacketContext::TProtocolType* aPdpType)

   936 	{

   937 	LOGTEXT(_L8("CGprsDGprsTsy::GetStaticCaps called"));

   938 

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

   940 	if (*aPdpType!=DPCKTTSY_PDP_TYPE1) 

   941 		{

   942 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   943 		}

   944 	else

   945 		{

   946 		*aCaps = DPCKTTSY_MISC_CAPS;

   947 		ReqCompleted(aTsyReqHandle,KErrNone);

   948 		}

   949 	return KErrNone;

   950 	}

   951 

   952 TInt CGprsDGprsTsy::GetDynamicCaps(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps)

   953 	{

   954 	LOGTEXT(_L8("CGprsDGprsTsy::GetDynamicCaps called"));

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

   956 	*aCaps = DPCKTTSY_DYNAMIC_CAPS1;

   957 	ReqCompleted(aTsyReqHandle,KErrNone);

   958 	return KErrNone;

   959 	}

   960 

   961 TInt CGprsDGprsTsy::NotifyDynamicCapsChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps)

   962 	{

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

   964 	if (!iNotifyDynamicCapsChange++)

   965 		{

   966 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyDynamicCapsChange called"));

   967 		*aCaps = DPCKTTSY_DYNAMIC_CAPS2;

   968 		ReqCompleted(aTsyReqHandle,KErrNone);

   969 		}

   970 	iTsyAsyncReqHandle = aTsyReqHandle;

   971 	return KErrNone;

   972 	}

   973 

   974 TInt CGprsDGprsTsy::NotifyDynamicCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)

   975 	{

   976 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyDynamicCapsChangeCancel called"));

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

   978 	if(aTsyReqHandle == iTsyAsyncReqHandle)

   979 		ReqCompleted(aTsyReqHandle,KErrCancel);

   980 	else

   981 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

   982 	return KErrNone;

   983 	}

   984 

   985 TInt CGprsDGprsTsy::SetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)

   986 /** 

   987  * SetAttachMode method - Sets the Attach mode for the context.

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

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

   990  * Note that the synchronous variant is deprecated.

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

   992  * 3 implement the asynchronous call.

   993  */

   994 	{

   995 	LOGTEXT(_L8("CGprsDGprsTsy::SetAttachMode called"));

   996 

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

   998 	switch (iSetAttachMode++)

   999 		{

  1000 		case 0:

  1001 		case 1:

  1002 			if (*aMode!=DPCKTTSY_ATTACH_MODE1)

  1003 				ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1004 			else

  1005 				ReqCompleted(aTsyReqHandle,KErrNone);

  1006 			break;

  1007 		case 2:

  1008 			if (*aMode!=DPCKTTSY_ATTACH_MODE2)

  1009 				ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1010 			else

  1011 				ReqCompleted(aTsyReqHandle,KErrNone);

  1012 			iTsyAsyncReqHandle = aTsyReqHandle;

  1013 			break;

  1014 		case 3:

  1015 			if (*aMode!=DPCKTTSY_ATTACH_MODE2)

  1016 				ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1017 			iTsyAsyncReqHandle = aTsyReqHandle;

  1018 			break;

  1019 		default:

  1020 			LOGTEXT(_L8("CGprsDGprsTsy::SetAttachMode - Error in switch statement"));

  1021 			break;

  1022 		} // switch

  1023 		

  1024 	return KErrNone;

  1025 	}

  1026 

  1027 TInt CGprsDGprsTsy::SetAttachModeCancel(const TTsyReqHandle aTsyReqHandle)

  1028 	{

  1029 	LOGTEXT(_L8("CGprsDGprsTsy::SetAttachModeCancel called"));

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

  1031 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1032 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1033 	else

  1034 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1035 	return KErrNone;

  1036 	}

  1037 

  1038 TInt CGprsDGprsTsy::GetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)

  1039 /** 

  1040  * GetAttachMode method - Gets the Attach mode for the context.

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

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

  1043  * Note that the synchronous variant is deprecated.

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

  1045  * 3 implement the asynchronous call.

  1046  */

  1047 	{

  1048 	LOGTEXT(_L8("CGprsDGprsTsy::GetAttachMode called"));

  1049 

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

  1051 	switch (iGetAttachMode++)

  1052 		{

  1053 		case 0:

  1054 		case 1:

  1055 			*aMode = DPCKTTSY_ATTACH_MODE2;

  1056 			ReqCompleted(aTsyReqHandle,KErrNone);

  1057 			break;

  1058 		case 2:

  1059 			*aMode = DPCKTTSY_ATTACH_MODE1;

  1060 			ReqCompleted(aTsyReqHandle,KErrNone);

  1061 		case 3:

  1062 			iTsyAsyncReqHandle = aTsyReqHandle;

  1063 			break;

  1064 		default:

  1065 			LOGTEXT(_L8("CGprsDGprsTsy::GetAttachMode - Error in switch statement"));

  1066 			break;

  1067 		} // switch

  1068 		

  1069 	return KErrNone;

  1070 	}

  1071 

  1072 TInt CGprsDGprsTsy::GetAttachModeCancel(const TTsyReqHandle aTsyReqHandle)

  1073 	{

  1074 	LOGTEXT(_L8("CGprsDGprsTsy::GetAttachModeCancel called"));

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

  1076 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1077 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1078 	else

  1079 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1080 	return KErrNone;

  1081 	}

  1082 	

  1083 TInt CGprsDGprsTsy::NotifyAttachModeChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode)

  1084 	{

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

  1086 	if (!iNotifyAttachModeChange++)

  1087 		{

  1088 		LOGTEXT(_L8("CGprsDGprsTsy::NotifyAttachModeChange called"));

  1089 		*aMode = DPCKTTSY_ATTACH_MODE2;

  1090 		ReqCompleted(aTsyReqHandle,KErrNone);

  1091 		}

  1092 	iTsyAsyncReqHandle = aTsyReqHandle;

  1093 	return KErrNone;

  1094 	}

  1095 

  1096 TInt CGprsDGprsTsy::NotifyAttachModeChangeCancel(const TTsyReqHandle aTsyReqHandle)

  1097 	{

  1098 	LOGTEXT(_L8("CGprsDGprsTsy::NotifyAttachModeChange called"));

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

  1100 	if(aTsyReqHandle == iTsyAsyncReqHandle)

  1101 		ReqCompleted(aTsyReqHandle,KErrCancel);

  1102 	else

  1103 		ReqCompleted(aTsyReqHandle,KErrCorrupt);

  1104 	return KErrNone;

  1105 	}

  1106 

  1107 TInt CGprsDGprsTsy::SetDefaultContextParams(const TTsyReqHandle aTsyReqHandle, const TDesC8* aPckg)

  1108 /** 

  1109  * SetDefaultContextParams method - Sets the Default context parameters.

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

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

  1112  * Note that the synchronous variant is deprecated.

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

  1114  * 3 implement the asynchronous call.

  1115  */

  1116 	{

  1117 	LOGTEXT(_L8("CGprsDGprsTsy::SetDefaultContextParams called"));

  1118 

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

  1120 	TPckg<TPacketDataConfigBase>* configBase = (TPckg<TPacketDataConfigBase>*)aPckg;

  1121 	TPacketDataConfigBase& configBaseV1 = (*configBase)();

  1122 

  1123 	switch (iSetDefaultContextParams++)

  1124 		{

  1125 		case 0:

  1126 		case 1:

  1127 			if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)

  1128 			{

  1129 			TPckg<RPacketContext::TContextConfigGPRS>* defaultContextGPRSPckg = (TPckg<RPacketContext::TContextConfigGPRS>*)aPckg;

  1130 			RPacketContext::TContextConfigGPRS& defaultContextV1 = (*defaultContextGPRSPckg)();

  1131 

  1132 			if ((defaultContextV1.iAccessPointName != DPCKTTSY_ACCESS_POINT1)||

  1133 			(defaultContextV1.iAnonymousAccessReqd != DPCKTTSY_ANONYMOUS_ACCESS1)||

  1134 			(defaultContextV1.iPdpAddress != DPCKTTSY_PDP_ADDRESS1)||