1 // Copyright (c) 2004-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 // SPUD event manager

    15 // WINSCW compiler has problems disambiguating TMetaDes8 and Meta::TMetaDes8 so

    16 // I prevent metabuffer.h from being recursively included from other headers

    17 // by defining its include guard.

    18 // 

    19 //

    20 

    21 /**

    22  @file

    23  @internalComponent

    24 */

    25 #define METABUFFER_H

    26 

    27 #include "spudman.h"

    28 #include "bindman.h"

    29 #include "mux.h"

    30 

    31 #include <comms-infras/dbaccess.h>

    32 #include "rpdpfsminterface.h"

    33 using namespace SpudMan; // Access the SpudFsm event names

    34 

    35 #include <etelpckt.h>

    36 #include <comms-infras/commsdebugutility.h>

    37 #include <in_sock.h>

    38 #include <networking/qos_if.h>

    39 #include <nifman.h>

    40 #include <comms-infras/es_config.h>

    41 

    42 #include <networking/umtsgprs_subconnprovfactory.h>

    43 #include <ss_glob.h>

    44 #include <ss_subconnprov.h>

    45 

    46 const TUint KQosPlugInProtocolId = 360; //< Plug-in protocol ID

    47 

    48 static const TInt KMaxInetAddrPrintSize = 50; //This should be big enough for an IPv6 printout

    49 

    50 

    51 #ifdef __FLOG_ACTIVE

    52 

    53 _LIT(KSpudUnknownLit, "Unknown event");

    54 

    55 _LIT(KSpudSoIfControllerPlugInLit, "KSoIfControllerPlugIn");

    56 _LIT(KSpudLitKRegisterEventHandler, "KRegisterEventHandler");

    57 _LIT(KSpudContextSetEventsLit, "KContextSetEvents");

    58 _LIT(KSpudNifSetDefaultQoSLit, "KNifSetDefaultQoS");

    59 _LIT(KSpudContextCreateLit, "KContextCreate");

    60 _LIT(KSpudContextDeleteLit, "KContextDelete");

    61 _LIT(KSpudContextActivateLit, "KContextActivate");

    62 _LIT(KSpudContextQoSSetLit, "KContextQoSSet");

    63 _LIT(KSpudContextTFTModifyLit, "KContextTFTModify");

    64 _LIT(KSpudGetNegQoSLit, "KGetNegQoS");

    65 _LIT(KSpudContextModifyActiveLit, "KContextModifyActive");

    66 _LIT(KInitialisePdpFsmLit, "KInitialisePdpFsm");

    67 

    68 

    69 static const TDesC *SpudGuQoSEventToText(TInt aEvent)

    70 	{

    71 	switch(aEvent)

    72 		{

    73 	case KSoIfControllerPlugIn:

    74 		return &KSpudSoIfControllerPlugInLit;

    75 	case KRegisterEventHandler:

    76 		return &KSpudLitKRegisterEventHandler;

    77 	case KContextSetEvents:

    78 		return &KSpudContextSetEventsLit;

    79 	case KNifSetDefaultQoS:

    80 		return &KSpudNifSetDefaultQoSLit;

    81 	case KContextCreate:

    82 		return &KSpudContextCreateLit;

    83 	case KContextDelete:

    84 		return &KSpudContextDeleteLit;

    85 	case KContextActivate:

    86 		return &KSpudContextActivateLit;

    87 	case KContextQoSSet:

    88 		return &KSpudContextQoSSetLit;

    89 	case KContextTFTModify:

    90 		return &KSpudContextTFTModifyLit;

    91 	case KGetNegQoS:

    92 		return &KSpudGetNegQoSLit;

    93 	case KContextModifyActive:

    94 		return &KSpudContextModifyActiveLit;

    95 	case KInitialisePdpFsm:

    96 		return &KInitialisePdpFsmLit;

    97 	default:

    98     	return &KSpudUnknownLit;

    99 		}

   100 	}

   101 	

   102 _LIT(KSpudContextDeleteEventLit, "KContextDeleteEvent");

   103 _LIT(KSpudContextActivateEventLit, "KContextActivateEvent");

   104 _LIT(KSpudContextParametersChangeEventLit, "KContextParametersChangeEvent");

   105 _LIT(KSpudContextBlockedEventLit, "KContextBlockedEvent");

   106 _LIT(KSpudContextUnblockedEventLit, "KContextUnblockedEvent");

   107 _LIT(KSpudNetworkStatusEventLit, "KNetworkStatusEvent");

   108 _LIT(KSpudContextQoSSetEventLit, "KContextQoSSetEvent");

   109 _LIT(KSpudContextTFTModifiedEventLit, "KContextTFTModifiedEvent");

   110 _LIT(KSpudPrimaryContextCreatedLit, "KPrimaryContextCreated");

   111 _LIT(KSpudSecondaryContextCreatedLit, "KSecondaryContextCreated");

   112 _LIT(KSpudGetNegQoSEventLit,"KGetNegQoSEvent");

   113 _LIT(KSpudContextModifyActiveEventLit, "KContextModifyActiveEvent");

   114 _LIT(KPdpFsmShuttingDownLit, "KPdpFsmShuttingDown");

   115 

   116 static const TDesC *SpudFsmEventToText(TInt aEvent)

   117 	{

   118 	switch(aEvent)

   119     	{

   120 	case KContextDeleteEvent:

   121 		return &KSpudContextDeleteEventLit;

   122 	case KContextActivateEvent:

   123 		return &KSpudContextActivateEventLit;

   124 	case KContextParametersChangeEvent:

   125 		return &KSpudContextParametersChangeEventLit;

   126 	case KContextBlockedEvent:

   127 		return &KSpudContextBlockedEventLit;

   128 	case KContextUnblockedEvent:

   129 		return &KSpudContextUnblockedEventLit;

   130 	case KNetworkStatusEvent:

   131 		return &KSpudNetworkStatusEventLit;

   132 	case KContextQoSSetEvent:

   133 		return &KSpudContextQoSSetEventLit;

   134 	case KContextTFTModifiedEvent:

   135 		return &KSpudContextTFTModifiedEventLit;

   136 	case KPrimaryContextCreated:

   137 		return &KSpudPrimaryContextCreatedLit;

   138 	case KSecondaryContextCreated:

   139 		return &KSpudSecondaryContextCreatedLit;

   140 	case KGetNegQoSEvent:

   141     		return &KSpudGetNegQoSEventLit;

   142     case KContextModifyActiveEvent:

   143     	return &KSpudContextModifyActiveEventLit;

   144    	case KPdpFsmShuttingDown:

   145     	return &KPdpFsmShuttingDownLit;

   146     default:

   147     	return &KSpudUnknownLit;

   148     	}

   149 	}

   150 

   151 _LIT(KSpudStateSpudInactiveLit, "ESpudInactive");

   152 _LIT(KSpudStateSpudHaveQosLit, "ESpudHaveQos");

   153 _LIT(KSpudStateSpudCreatingPrimary, "ESpudCreatingPrimary");

   154 _LIT(KSpudStateSpudStartingPrimaryLit, "ESpudStartingPrimary");

   155 _LIT(KSpudStateSpudStartingPrimaryLowerNifLit, "ESpudStartingPrimaryLowerNif");

   156 _LIT(KSpudStateSpudStartingSecondaryLit, "ESpudStartingSecondary");

   157 _LIT(KSpudStateSpudStartingSecondaryLowerNifLit, "ESpudStartingSecondaryLowerNif");

   158 _LIT(KSpudStateSpudGettingNegQoSLit, "ESpudGettingNegQoS");

   159 _LIT(KSpudStateSpudUpLit, "ESpudUp");

   160 _LIT(KSpudStateSpudFlowOffLit, "ESpudFlowOff");

   161 _LIT(KSpudStateSpudSuspendedLit, "ESpudSuspended");

   162 _LIT(KSpudStateSpudFlowOffAndSuspendedLit, "ESpudFlowOffAndSuspended");

   163 _LIT(KSpudStateSpudLinkDownLit, "ESpudLinkDown");

   164 _LIT(KSpudStateSpudContextDeleteLit, "ESpudContextDelete");

   165 _LIT(KSpudStateSpudWaitLinkDownLit, "ESpudWaitLinkDown");

   166 _LIT(KSpudStateSpudWaitBinderDeleteLit, "ESpudWaitBinderDelete");

   167 _LIT(KSpudStateUnknownLit, "Unknown spud state");

   168 	

   169 static const TDesC *SpudStateToText(TSpudContextStates aState)

   170 	{

   171 	switch(aState)

   172     	{

   173 	case ESpudInactive:

   174 		return &KSpudStateSpudInactiveLit;

   175 	case ESpudHaveQos:

   176 		return &KSpudStateSpudHaveQosLit;

   177 	case ESpudCreatingPrimary:

   178 		return &KSpudStateSpudCreatingPrimary;

   179 	case ESpudStartingPrimary:

   180 		return &KSpudStateSpudStartingPrimaryLit;

   181 	case ESpudStartingPrimaryLowerNif:

   182 		return &KSpudStateSpudStartingPrimaryLowerNifLit;

   183 	case ESpudStartingSecondary:

   184 		return &KSpudStateSpudStartingSecondaryLit;

   185 	case ESpudStartingSecondaryLowerNif:

   186 		return &KSpudStateSpudStartingSecondaryLowerNifLit;

   187 	case ESpudGettingNegQoS:

   188 		return &KSpudStateSpudGettingNegQoSLit;

   189 	case ESpudUp:

   190 		return &KSpudStateSpudUpLit;

   191 	case ESpudFlowOff:

   192 		return &KSpudStateSpudFlowOffLit;

   193 	case ESpudSuspended:

   194 		return &KSpudStateSpudSuspendedLit;

   195 	case ESpudFlowOffAndSuspended:

   196 		return &KSpudStateSpudFlowOffAndSuspendedLit;

   197 	case ESpudLinkDown:

   198 		return &KSpudStateSpudLinkDownLit;

   199 	case ESpudContextDelete:

   200 		return &KSpudStateSpudContextDeleteLit;

   201 	case ESpudWaitLinkDown:

   202 		return &KSpudStateSpudWaitLinkDownLit;

   203 	case ESpudWaitBinderDelete:

   204 		return &KSpudStateSpudWaitBinderDeleteLit;

   205 	default:

   206     	return &KSpudStateUnknownLit;

   207     	}

   208 	}

   209 

   210 #endif

   211 

   212 CSpudMan::CSpudMan(CNifIfFactory& aFactory, MNifIfNotify* aNotify)

   213 	: CNifIfLink(aFactory),

   214 	iContextStatusOverride(RPacketContext::EStatusUnknown)

   215 	{

   216     iNotify = aNotify;

   217     ASSERT(iNotify);

   218 	__FLOG_OPEN(KSpudFirstTag,KSpudLog);

   219     __FLOG_0(_L("CSpudMan::CSpudMan"));

   220 	}

   221 

   222 CSpudMan::~CSpudMan()

   223    {

   224    if (iBindMan)

   225       {

   226       // Only log if ConstructL() was called, where logger was initialized

   227       __FLOG_0(_L("CSpudMan::~CSpudMan"));

   228       }

   229    

   230    

   231    if (AreQoSEventsEnabled())

   232       {

   233       // Spud is being destroyed by Nifman. Tell GUQoS to stop bothering SPUD.

   234       // GUQoS returns the favour by turning off the NIF events within this very call.

   235       // *********************************************************************************************

   236       // N.B.: "DEF055691 	GUQoS crashes at shutdown": This defect results in GUQoS crash if the stack

   237       // closes flows after the NIF proxy was deleted by GUQoS, as a result of KNetworkInterfaceDown event.

   238       // Because of this defect, we cannot signal KNetworkInterfaceDown from anywhere but here. Once it is fixed,

   239       // calls from the appropriate places will be enabled, and the line below will not be strictly necessary.

   240       SendNetworkStatusEvent(KNetworkInterfaceDown, RPacketService::EStatusUnattached);

   241       // For safety, we should call this from here in any case.

   242       //**********************************************************************************************

   243       }

   244    

   245    delete iParkedDefaultQoS;

   246    delete iBinderSweeperNotifierCb;

   247    

   248    delete iBindMan;

   249    iPdpFsmInterface.Close();

   250    iSipServerAddr.Close();

   251    __FLOG_CLOSE;

   252    }

   253 

   254 /**

   255 Panics the current thread.

   256 

   257 @param aReason Panic reason code

   258 */

   259 void CSpudMan::Panic(TInt aReason) const

   260 	{

   261     __FLOG_1(_L("CSpudMan::Panic with reason %d"), aReason);

   262 	User::Panic(KSpudName, aReason);

   263 	}

   264 

   265 /**

   266 Construct the Link Protocol Object

   267 

   268 @param aBindMan Pointer to BindMan object (ownership is transferred)

   269 @leave leaves if could not allocate memory

   270 */

   271 void CSpudMan::ConstructL(CBindMan* aBindMan)

   272 	{

   273     __FLOG_1(_L("CSpudMan starting %x"), iNotify);

   274 

   275 

   276 	iBindMan = aBindMan;

   277 	ASSERT(iBindMan);

   278 	

   279 	// The lower NIF binder deletion & Nifman notification callback

   280 	iBinderSweeperNotifierCb = new (ELeave) CBinderSweeperNotifierCb(*this);

   281 	}

   282 

   283 

   284 /**

   285 Implements the Control method of CNifBase - used for retrieval of the P-CSCF (Sip Server) address

   286 */	

   287 TInt CSpudMan::Control(TUint aLevel,TUint aName,TDes8& aOption, TAny*)

   288 	{

   289 	if (aLevel == KCOLConfiguration && aName == KConnGetSipServerAddr)

   290 		{

   291 		if (aOption.Length() != sizeof (SSipServerAddr))

   292 			{

   293 			__FLOG(_L("CSpudMan::Control - Invalid Descriptior - Descriptor Must contain an SSipServerAddr"));

   294 			Panic();

   295 			}

   296 		SSipServerAddr* sipServerAddr = reinterpret_cast<SSipServerAddr*>(const_cast<TUint8*>(aOption.Ptr()));

   297 		if (sipServerAddr->index < 0 || sipServerAddr->index >= iSipServerAddr.Count())

   298 			{

   299 			__FLOG_1(_L("CSpudMan::Control - Index out of range : value = %d"), sipServerAddr->index);

   300 			return KErrNotFound;

   301 			}

   302 		sipServerAddr->address = iSipServerAddr[sipServerAddr->index];

   303 #ifdef __FLOG_ACTIVE

   304 		TBuf<KMaxInetAddrPrintSize> buf;

   305 		sipServerAddr->address.Output(buf);

   306 		__FLOG_2(_L("CSpudMan::Control Address %S returned for index %d"), &buf, sipServerAddr->index);

   307 #endif

   308 		return KErrNone;				

   309 		}

   310 	return KErrNotSupported;	

   311 	}

   312 

   313 

   314 /**

   315 Retrieve any GPRS settings required from CommDB

   316 

   317 @param aConfigGprs Context configuration parameters to be filled in

   318 */

   319 void CSpudMan::RetrieveGprsConfig(RPacketContext::TContextConfigGPRS& aConfigGprs) const

   320 	{

   321 	TUint32 pdpType(0);

   322 	Notify()->ReadInt(TPtrC(GPRS_PDP_TYPE), pdpType);

   323  	__FLOG_1(_L8("ReadInt GPRS_PDP_TYPE [%d]"), pdpType);

   324 	aConfigGprs.iPdpType = STATIC_CAST(RPacketContext::TProtocolType, pdpType);

   325 

   326 	Notify()->ReadDes(TPtrC(GPRS_APN), aConfigGprs.iAccessPointName);

   327   	__FLOG_1(_L8("ReadDes GPRS_APN [%S]"), &aConfigGprs.iAccessPointName);

   328 

   329 		

   330 	TBool fromServer;

   331 	aConfigGprs.iPdpAddress.SetLength(0);

   332 	Notify()->ReadBool(TPtrC(GPRS_IP_ADDR_FROM_SERVER), fromServer);

   333 	if (!fromServer)

   334 	    {

   335     	Notify()->ReadDes(TPtrC(GPRS_IP_ADDR), aConfigGprs.iPdpAddress);

   336 	    }

   337 	

   338 

   339     // We can only use IPv4 or IPv6 - we use the first one listed in the IfNetworks field

   340     TBuf<KCommsDbSvrMaxFieldLength> networks;

   341 	Notify()->ReadDes(TPtrC(LAN_IF_NETWORKS), networks);

   342 

   343 	ASSERT(networks.Length() > 0); // If the IfNetworks field is empty there is a serious misconfiguration

   344 	

   345 	TInt pos = networks.Find(_L(","));

   346 	if (pos == KErrNotFound)

   347 	    {

   348 	    pos = networks.Length();

   349 	    }

   350 	TPtrC protocol(networks.Ptr(), pos);

   351 	_LIT(KIp4, "ip");

   352 	_LIT(KIp6, "ip6");

   353 	if (protocol.CompareF(KIp4) == 0)

   354 	    {

   355 	    // IPv4 settings

   356     	Notify()->ReadBool(TPtrC(GPRS_IP_DNS_ADDR_FROM_SERVER), fromServer);

   357     	if (!fromServer)

   358     	    {

   359     	    Notify()->ReadDes(TPtrC(GPRS_IP_NAME_SERVER1), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

   360     	    Notify()->ReadDes(TPtrC(GPRS_IP_NAME_SERVER2), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

   361     	    }

   362 	    }

   363 	else if (protocol.CompareF(KIp6) == 0)

   364 	    {

   365 	    // IPv6 settings

   366     	Notify()->ReadBool(TPtrC(GPRS_IP6_DNS_ADDR_FROM_SERVER), fromServer);

   367     	if (!fromServer)

   368     	    {

   369     	    Notify()->ReadDes(TPtrC(GPRS_IP6_NAME_SERVER1), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

   370     	    Notify()->ReadDes(TPtrC(GPRS_IP6_NAME_SERVER2), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

   371     	    }

   372 	    }

   373 	else

   374 	    {

   375 	    // Anything else is a serious misconfiguration

   376 	    ASSERT(0);

   377 	    }

   378 	

   379 	RetrieveGprsCompression(aConfigGprs.iPdpCompression);

   380 	 __FLOG_1(_L8("Read GprsCompression [%d]"), aConfigGprs.iPdpCompression);

   381 

   382 	RetrieveGprsAnonymousAccess(aConfigGprs.iAnonymousAccessReqd);

   383  	__FLOG_1(_L8("Read AnonymousAccess [%d]"), aConfigGprs.iAnonymousAccessReqd);

   384 

   385 	TBuf<KCommsDbSvrMaxUserIdPassLength> readBuf;

   386 	Notify()->ReadDes(TPtrC(SERVICE_IF_AUTH_NAME), readBuf);

   387 	aConfigGprs.iProtocolConfigOption.iAuthInfo.iUsername.Copy(readBuf);

   388 	readBuf.Zero();

   389 	Notify()->ReadDes(TPtrC(SERVICE_IF_AUTH_PASS), readBuf);

   390 	aConfigGprs.iProtocolConfigOption.iAuthInfo.iPassword.Copy(readBuf);

   391  	__FLOG_2(_L8("ReadDes SERVICE_IF_AUTH_NAME [%S] and SERVICE_IF_AUTH_PASS [%S]"), &aConfigGprs.iProtocolConfigOption.iAuthInfo.iUsername, 

   392 			 &aConfigGprs.iProtocolConfigOption.iAuthInfo.iPassword);

   393 

   394 	aConfigGprs.iUseEdge = EFalse;

   395 	}

   396 

   397 void CSpudMan::RetrieveGprsCompression(TUint& aCompression) const

   398 	{

   399 	aCompression = 0;

   400 	TBool isCompression = EFalse;

   401 	Notify()->ReadBool(TPtrC(GPRS_DATA_COMPRESSION), isCompression);

   402 	if (isCompression)

   403 		{

   404 		aCompression |= RPacketContext::KPdpDataCompression;

   405 		}

   406 

   407 	isCompression = EFalse;

   408 	Notify()->ReadBool(TPtrC(GPRS_HEADER_COMPRESSION), isCompression);

   409 	if (isCompression)

   410 		{

   411 		aCompression |= RPacketContext::KPdpHeaderCompression;

   412 		}

   413 	}

   414 

   415 void CSpudMan::RetrieveGprsAnonymousAccess(RPacketContext::TAnonymousAccess& aAnonymous) const

   416 	{	

   417 	TBool isAnonymous = EFalse;

   418 	Notify()->ReadBool(TPtrC(GPRS_ANONYMOUS_ACCESS),isAnonymous);

   419 	if (isAnonymous)

   420 		aAnonymous = RPacketContext::ERequired;

   421 	else

   422 		aAnonymous = RPacketContext::ENotRequired;

   423 	}

   424 

   425 

   426 

   427 /**

   428 Indicates whether QoS has been enabled or not.

   429 

   430 @return ETrue if QoS has been enabled for this NIF.

   431 */

   432 TBool CSpudMan::AreQoSEventsEnabled() const

   433 	{

   434 	return iQosEventHandler != NULL;

   435 	}

   436 

   437 

   438 /**

   439 Returns pointer to BindMan.

   440 

   441 @return Pointer to BindMan object

   442 */

   443 CBindMan* CSpudMan::BindMan() const

   444 	{

   445 	return iBindMan;

   446 	}

   447 

   448 /**

   449 Returns pointer to the MNifIfNotify object in NIFMAN.

   450 

   451 @return Pointer to MNifIfNotify object

   452 */

   453 MNifIfNotify* CSpudMan::Notify() const

   454 	{

   455 	ASSERT(iNotify);

   456 	return iNotify;

   457 	}

   458 

   459 /**

   460 Set default QoS parameters from the values in CommDb.

   461 

   462 @param aQos QoS parameters filled in on exit

   463 */

   464 void CSpudMan::ReadDefaultQoS(RPacketQoS::TQoSR99_R4Requested& aQos) const

   465 	{

   466 	TBuf<2*KCommsDbSvrMaxColumnNameLength+1> columnName;

   467 	_LIT(KFormatText,"%s\\%s");

   468 

   469 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_TRAFFIC_CLASS);

   470 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqTrafficClass));

   471 

   472 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_TRAFFIC_CLASS);

   473 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinTrafficClass));

   474 	

   475 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_DELIVERY_ORDER);

   476 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqDeliveryOrderReqd));

   477 

   478 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_DELIVERY_ORDER);

   479 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinDeliveryOrderReqd));

   480 	

   481 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_DELIVER_ERRONEOUS_SDU);

   482 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqDeliverErroneousSDU));

   483 

   484 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_DELIVER_ERRONEOUS_SDU);

   485 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinDeliverErroneousSDU));

   486 	

   487 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MAX_SDUSIZE);

   488 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqMaxSDUSize));

   489 

   490 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_ACCEPTABLE_MAX_SDU_SIZE);

   491 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinAcceptableMaxSDUSize));

   492 	

   493 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MAX_UPLINK_RATE);

   494 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqMaxRate.iUplinkRate));

   495 

   496 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MIN_UPLINK_RATE);

   497 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinAcceptableMaxRate.iUplinkRate));

   498 	

   499 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MAX_DOWNLINK_RATE);

   500 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqMaxRate.iDownlinkRate));

   501 	

   502 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MIN_DOWNLINK_RATE);

   503 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinAcceptableMaxRate.iDownlinkRate));

   504 	

   505 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_BER);

   506 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqBER));

   507 	

   508 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MAX_BER);

   509 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMaxBER));

   510 	

   511 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_SDU_ERROR_RATIO);

   512 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqSDUErrorRatio));

   513 	

   514 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MAX_SDU_ERROR_RATIO);

   515 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMaxSDUErrorRatio));

   516 

   517 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_TRAFFIC_HANDLING_PRIORITY);

   518 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqTrafficHandlingPriority));

   519 	

   520 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_TRAFFIC_HANDLING_PRIORITY);

   521 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinTrafficHandlingPriority));

   522 

   523 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_TRANSFER_DELAY);

   524 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqTransferDelay));

   525 	

   526 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MAX_TRANSFER_DELAY);

   527 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMaxTransferDelay));

   528 

   529 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_GUARANTEED_UPLINK_RATE);

   530 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqGuaranteedRate.iUplinkRate));

   531 

   532 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_GUARANTEED_UPLINK_RATE);

   533 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinGuaranteedRate.iUplinkRate));

   534 

   535 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_GUARANTEED_DOWNLINK_RATE);

   536 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqGuaranteedRate.iDownlinkRate));

   537 

   538 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_GUARANTEED_DOWNLINK_RATE);

   539 	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinGuaranteedRate.iDownlinkRate));

   540 	}

   541 

   542 #ifdef SYMBIAN_NETWORKING_UMTSR5

   543 /**

   544 Set default R5 QoS parameters from the values in CommDb.

   545 

   546 @param aQos R5 QoS parameters filled in on exit

   547 */

   548 void CSpudMan::ReadDefaultR5QoS(RPacketQoS::TQoSR5Requested& aQos) const

   549 	{

   550 	ReadDefaultQoS(aQos);

   551 	

   552 	TBuf<2*KCommsDbSvrMaxColumnNameLength+2> columnName;

   553 	_LIT(KFormatText,"%s\\%s");

   554 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_SIGNALLING_INDICATION);

   555 	Notify()->ReadBool (columnName, aQos.iSignallingIndication);

   556 	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_SOURCE_STATISTICS_DESCRIPTOR);

   557 	Notify()->ReadInt(columnName, reinterpret_cast<TUint32&>(aQos.iSourceStatisticsDescriptor));

   558 	}

   559 #endif

   560 // SYMBIAN_NETWORKING_UMTSR5

   561 

   562 

   563 /**

   564 Reads TSY name from CommDb.

   565 

   566 @param aTsyName TSY name filled in on exit

   567 */

   568 void CSpudMan::ReadTsyName(TName& aTsyName) const

   569 	{

   570 	TBuf<2*KCommsDbSvrMaxColumnNameLength+1> columnName;

   571 	_LIT(KFormatText,"%s\\%s");

   572 	columnName.Format(KFormatText,MODEM_BEARER,MODEM_TSY_NAME);

   573 	Notify()->ReadDes(columnName, aTsyName); // ignore error

   574 	}

   575 

   576 /**

   577 Sets the error code to use for termination, unless it is already set.

   578 

   579 @param aError Error code to use when notifying NIFMAN

   580 */

   581 void CSpudMan::SetTerminateError(TInt aError)

   582 	{

   583 	if (iTerminateError == KErrNone)

   584 		{

   585 		iTerminateError = aError;

   586 		__FLOG_1(_L("Set SPUD termination error to [%d]"), aError);

   587 		

   588 		// There is no specific context associated with this termination

   589 		// So prevent a later overwrite of the error by the ETel error

   590 		if (iETelTerminateError == KErrNone)

   591 			{

   592 			iETelTerminateError = aError;

   593 			}

   594 		}

   595 	}

   596 

   597 /**

   598 Sets the error code to use for termination, unless it is already set.

   599 

   600 @param aContextId context ID

   601 @param aError Error code to use when notifying NIFMAN

   602 */

   603 void CSpudMan::SetTerminateError(TContextId aContextId, TInt aError)

   604 	{

   605 	if (iTerminateError == KErrNone)

   606 		{

   607 		iTerminateError = aError;

   608 		

   609 		// Now check to see if ETel was the originator of this error

   610 		if (iETelTerminateError == KErrNone)

   611 			{

   612 			// ask for the last ETel error received - ignore return code

   613 			iPdpFsmInterface.GetLastErrorCause(aContextId, iETelTerminateError);

   614 			}

   615 

   616 		if (iETelTerminateError != KErrNone)

   617 			{

   618 			// Overwrite with the most likely original error code!

   619 			iTerminateError = iETelTerminateError;

   620 			}

   621 	

   622 		__FLOG_1(_L("Set SPUD termination error to [%d]"), iTerminateError);

   623 		}

   624 		

   625 	}

   626 

   627 //*****************************************************************************

   628 // Events receivers

   629 //*****************************************************************************

   630 

   631 /**

   632 Receives events from SpudFsm.

   633 

   634 @param aContextId context ID

   635 @param aEvent event ID

   636 @param aParam optional parameter to event

   637 */

   638 void CSpudMan::Input(TContextId aContextId, TInt aEvent, TInt aParam)

   639 	{

   640 	__FLOG_4(_L("SpudMan::Input: SpudFsm event %S(%d) param[%d] context[%d]"), SpudFsmEventToText(aEvent), aEvent, aParam, aContextId);

   641 	ASSERT(aContextId == KAllContexts || (aContextId >=0 && aContextId < KMaxPdpContexts));

   642 	

   643 	switch (aEvent)

   644 		{

   645 	case KPrimaryContextCreated:

   646 		{

   647 		HandlePrimaryContextCreatedEvent(aContextId, aParam);

   648 		break;

   649 		}

   650 	

   651 	case KContextDeleteEvent:

   652 		{

   653 		HandleContextDeleteEvent(aContextId, aParam);

   654 		break;

   655 		}

   656 

   657 	case KSecondaryContextCreated:

   658 		{

   659 		HandleSecondaryContextCreatedEvent(aContextId, aParam);

   660 		break;

   661 		}

   662 

   663 	case KContextActivateEvent:

   664 		{

   665 		HandleContextActivateEvent(aContextId, aParam);

   666 		break;

   667 		}

   668 

   669 	case KContextQoSSetEvent:

   670 		{

   671 		HandleContextQoSSetEvent(aContextId, aParam);

   672 		break;

   673 		}

   674 

   675 	case KContextTFTModifiedEvent:

   676 		{

   677 		HandleContextTFTModifiedEvent(aContextId, aParam);

   678 		break;

   679 		}

   680 

   681 	case KGetNegQoSEvent:

   682 		{

   683 		HandleGetNegQoSEvent(aContextId, aParam);

   684 		break;

   685 		}

   686 

   687 	case KContextModifyActiveEvent:

   688 		{

   689 		HandleContextModifyActiveEvent(aContextId, aParam);

   690 		break;

   691 		}

   692 

   693 	case KNetworkStatusEvent:

   694 		{

   695 		HandleNetworkStatusEvent();

   696 		break;

   697 		}

   698 

   699 	case KContextParametersChangeEvent:

   700 		{

   701 		HandleContextParametersChangeEvent(aContextId, aParam);

   702         break;

   703 		}

   704 

   705 	case KContextBlockedEvent:

   706 		{

   707 		HandleContextBlockedEvent(aContextId);

   708 		break;

   709 		}

   710 

   711 	case KContextUnblockedEvent:

   712 		{

   713 		HandleContextUnblockedEvent(aContextId);

   714 		break;

   715 		}

   716 

   717 

   718    case KPdpFsmShuttingDown:

   719       {

   720       __FLOG_0(_L("UmtsGprsSCPR has shutdown the PDP Fsm Interface"));

   721       iPdpFsmInterface.Close();

   722       break;

   723       }

   724 

   725 	default:

   726 		__FLOG_1(_L("Unhandled event %d"), aEvent);

   727 		ASSERT(EFalse);

   728 		break;

   729 		}

   730 	}

   731 	

   732 void CSpudMan::InitPdpFsmInterfaceL()

   733 	{

   734 	class XAssociatedNifConnectionProviderQuery : public MFactoryQuery

   735 	/**	Finds the connection provider associated with the specified Nif.

   736 	@internalTechnology

   737 	*/

   738 		{

   739 	public:

   740 		XAssociatedNifConnectionProviderQuery( const TDesC& aName, ::TMetaDes8& aNameBuffer ) : iNifName( aName ), iNifNameBuffer( aNameBuffer )

   741 			{

   742 			}

   743 

   744 		virtual TMatchResult Match( TFactoryObjectInfo& aObjectInfo )

   745 			{

   746 			TConnInterfaceName& name = *reinterpret_cast<TConnInterfaceName*>( const_cast<TUint8*>( iNifNameBuffer.iDes->Ptr() ) );

   747 			name.iIndex = 1;

   748 

   749 			TInt err = KErrNone;

   750 			TMatchResult result = EContinue;

   751 			

   752 			// Check each of the connection provider interfaces' names to see if it

   753 			// is associated with this NIF.

   754 			while( ETrue )

   755 				{

   756 		        TRAP( err, static_cast<CConnectionProviderBase*>( aObjectInfo.iInfo.iFactoryObject )->ControlL(KCOLProvider, KConnGetInterfaceName, iNifNameBuffer, NULL) );

   757 		        

   758 		        if( err == KErrNone )

   759 		        	{

   760 		        	if( name.iName == iNifName )

   761 			        	{

   762 				       	result = EMatch;

   763 				       	

   764 				       	break;

   765 			        	}

   766 			       	}

   767 			    else

   768 			    	{

   769 			    	break;

   770 			    	}

   771 

   772 				name.iIndex ++;

   773 				}

   774 	        	

   775 	        return result;

   776 			}

   777 			

   778 	private:

   779 		const TDesC& iNifName;

   780 		::TMetaDes8& iNifNameBuffer;

   781 		};

   782 

   783 	const TUint KShimConnectionProviderFactoryId = 0x10207104; //the same as CSubConnectionProviderFactoryShim

   784 

   785 	TSockManData* sockManData = SockManGlobals::Get();

   786 	ASSERT(sockManData);

   787 

   788 	CConnectionFactoryContainer* connectionFactories = sockManData->iConnectionFactories;

   789 	ASSERT(connectionFactories);

   790 

   791 	CConnectionProviderFactoryBase *factory = connectionFactories->FindFactory(KShimConnectionProviderFactoryId);

   792 	if(!factory)

   793 		{

   794 		User::Leave( KErrNotFound );

   795 		}

   796 		

   797 	CSpudMux* mux = iBindMan->SpudMux();

   798 

   799 	// Get the name of our SPUDMUX interface - it uniquely identifies this SPUD object assembly.

   800 	TNifIfInfo info;

   801 	mux->Info( info );

   802 

   803 	// Create a buffer to hold the name of each interface we check to see if the interface is our SPUDMUX.

   804 	TPckgBuf<TConnInterfaceName> name;

   805 	TPtrC8 desC( name );

   806 	::TMetaDes8* des = ::TMetaDes8::NewL( &desC );

   807 

   808 	XAssociatedNifConnectionProviderQuery connProviderQuery( info.iName, *des );

   809 	

   810 	// Find the connection provider associated with this NIF.

   811 	CConnectionProviderBase* connectionProvider = factory->FindProvider(connProviderQuery);

   812 	delete des;

   813 	if(!connectionProvider)

   814 		{

   815 		User::Leave( KErrNotFound );

   816 		}

   817 

   818 	CSubConnectionFactoryContainer* subConnectionFactories = sockManData->iSubConnectionFactories;

   819 	ASSERT(subConnectionFactories);

   820 

   821 	TDataClientQuery subConnProviderQuery(connectionProvider, ESubConnPlane, RSubConnection::EAttachToDefault);

   822 

   823 	// Find the default subconnection provider.

   824 	CSubConnectionProviderBase* subConnProvider = subConnectionFactories->FindOrCreateProviderL(connectionProvider->CanDoSubConnection(RSubConnection::EAttachToDefault), subConnProviderQuery);

   825 	if(!subConnProvider || subConnProvider->Factory().Id() != KUmtsGprsSubConnectionProviderFactoryId)

   826 		{

   827 		User::Leave( KErrNotFound );

   828 		}

   829 

   830 	// Initialise the PDP FSM interface.

   831 	TPckg<CNifIfBase*> nifPckg(mux);

   832 	User::LeaveIfError(subConnProvider->Control(KSOLInterface, KInitialisePdpFsm, nifPckg));

   833 	}

   834 

   835 void CSpudMan::HandlePrimaryContextCreatedEvent(TContextId aContextId, TInt aError)

   836 	{

   837 		

   838 	// Save the contextId for later

   839 	iPrimaryContextId = aContextId;

   840 	

   841 	// Primary context has been created; Start the lower NIF

   842 	CSpudBinderRef* ref = NULL;

   843 	TRAPD(rc, ref = iBindMan->GetRefL(aContextId));

   844 	__FLOG_2(_L("Got lower NIF binder for context[%d] with error[%d]"), aContextId, rc);

   845 	if (rc == KErrNone)

   846 		{

   847 		// Make sure context was created successfully

   848 		rc = aError;

   849 		ASSERT(ref->IsBound());

   850 		__FLOG_3(_L("context %d is in state %S(%d)"), aContextId, SpudStateToText(ref->State()), ref->State());

   851 		}

   852 

   853 	if (KErrNone == rc) // Context created successfully.

   854 		{

   855 			// Get the details of the P-CSCF 

   856 		RPacketContext::TContextConfigGPRS config;

   857 		

   858 		if (iPdpFsmInterface.Get(aContextId, config) == KErrNone)

   859 			{

   860 			TRAP(rc, SetSipServerAddrL(config.iProtocolConfigOption););

   861 				{

   862 				__FLOG_1(_L("CSpudMan::HandlePrimaryContextCreatedEvent -Error occurred extracting the sip server address: %d"),rc);

   863 				//rc is now non zero, therefore should fail gracefully

   864 				}	

   865 #ifdef SYMBIAN_NETWORKING_UMTSR5

   866 			// Since the value or IMCN Signalling flag also comes in PCO IE buffer along with the SipAddress, we

   867 			// need to extract the value here and set it to Parameter Bundle of SCPR

   868 				TBool imcn = EFalse;		

   869 				TRAPD(err,imcn=GetIMCNSignallingFlagPcoL(config.iProtocolConfigOption););

   870 				__FLOG_1(_L("CSpudMan::GetIMCNSignallingFlagPcoL - returns eror=%d"),err);

   871 				if (err == KErrNone)

   872 					{

   873 					iPdpFsmInterface.SetIMCNSignalling(imcn); //imcn contains ETrue or Efalse

   874 #ifdef __FLOG_ACTIVE

   875 					if (imcn)

   876 						{

   877 						__FLOG_0(_L("CSpudMan::HandlePrimaryContextCreatedEvent - Network ACCEPTS the request for dedicated IMCN Signalling Flag "));

   878 						}

   879 					else

   880 						{

   881 						__FLOG_0(_L("CSpudMan::HandlePrimaryContextCreatedEvent - Network REJECTS the request for dedicated IMCN Signalling Flag "));				

   882 						}

   883 #endif 

   884 					}

   885 					else

   886 					{

   887 					

   888 #ifdef __FLOG_ACTIVE

   889 					__FLOG_1(_L("CSpudMan::HandlePrimaryContextCreatedEvent -Leave Error occurred  %d"),err);

   890 #endif

   891 					}			

   892 #endif // SYMBIAN_NETWORKING_UMTSR5

   893 			}

   894 		}

   895 		

   896 	if (KErrNone == rc) // Sip server address retrieved

   897 		{

   898 		ASSERT(ref->State() == ESpudCreatingPrimary);

   899 	    ref->SetState(ESpudStartingPrimary);

   900 	    // Start the lower NIF and wait for the LinkLayerUp call

   901 		rc = ref->NifLink()->Start(); 

   902 		if(KErrNone == rc)

   903 			{

   904 			ref->SetState(ESpudStartingPrimaryLowerNif);

   905 			}

   906 		// Lower NIF may still report failure to Start by signalling LinkLayerDown with error.

   907 		// E.G. PPP negotiation may fail.

   908 		__FLOG_2(_L("Lower NIF for Primary Context[%d] started with error[%d]."), aContextId, rc);

   909 		}

   910 

   911 		

   912 	// Catch-all error handling: Could not create context, or could not start lower NIF.	

   913 	if(KErrNone != rc) 

   914 		{			

   915 		SetTerminateError(rc);	

   916 		

   917 	    SendPrimaryContextCreated(aContextId, rc); // Notify GUQoS of error

   918 

   919  		if(ESpudStartingPrimary == ref->State()) // Context created 

   920  			{

   921  			ref->SetState(ESpudWaitLinkDown); // We've just notified GUQoS.

   922  			// Delete context via SpudFsm

   923 			__FLOG_2(_L("Failed to start lower NIF for Primary PDP context[%d] due to error[%d]. Deleting Primary via SpudFsm."), aContextId, rc);

   924 			rc = iPdpFsmInterface.Input(aContextId, EContextDelete);

   925 			ASSERT(rc == KErrNone);

   926  			}

   927  		else 	// Context was not created, else we would not be here. There is nothing to stop and delete.

   928  			{

   929  			__FLOG_1(_L("Failed to create Primary context[%d]. Spud will shut down."), aContextId);

   930 			

   931  			if (AreQoSEventsEnabled())

   932 				{

   933 				// At this point we know that SPUD is about to shut down, because we are

   934 				// deleting the last context. We want to indicate to the upper layers early that

   935 				// data can no longer be sent to SPUD.

   936 									

   937 				// Tell GUQoS to stop bothering SPUD.

   938 				// GUQoS returns the favour by turning off the NIF events within this very call.

   939 				// This means we won't send KNetworkInterfaceDown, even if we try.

   940 		   		// *********************************************************************************************

   941 				// N.B.: "DEF055691 	GUQoS crashes at shutdown": This defect results in GUQoS crash if the stack

   942     			// closes flows after the NIF proxy was deleted by GUQoS, as a result of KNetworkInterfaceDown event.

   943     			// As a temporary workaround, this call is disabled, and KNetworkInterfaceDown event is signalled only

   944     			// from the destructor. Once this defect is fixed, the following line must be uncommented: 

   945     			// SendNetworkStatusEvent(KNetworkInterfaceDown, RPacketService::EStatusUnattached);

   946 				//**********************************************************************************************

   947 		   		}

   948 			// We are about to delete the primary context NIF: this will notify Nifman that SPUD is finished.

   949  			DisposeOfBinder(ref);

   950  			}

   951  		}		

   952 	}

   953 

   954 void CSpudMan::HandleContextDeleteEvent(TContextId aContextId, TInt aError)

   955 	{

   956 	aError = aError; // suppress compiler warning

   957 	// Ignore error on delete--nothing we can do, anyway

   958 	// For the upper layers, we treat this event as KErrDisconnected, because the network has torn down an 

   959 	// existing context.

   960 	CSpudBinderRef* ref = NULL;

   961 	TRAPD(rc, ref = iBindMan->GetRefL(aContextId));

   962 	__ASSERT_ALWAYS(rc == KErrNone, Panic());

   963 	ASSERT(ref->IsBound());

   964 	__FLOG_4(_L("Network deleted context %d, in state %S(%d). Deletion error=%d"),

   965 		aContextId, SpudStateToText(ref->State()), ref->State(), aError);

   966 	

   967 	// Are we about to shut down after this context is deleted?

   968 	TBool shutdownStarted(BindMan()->IsLastContext(aContextId));

   969 	// We must determine this before we make any state transitions. But we can act on this

   970 	// only after we've done all GUQoS notifications to make sure shutdown is graceful.

   971 	

   972 	switch (ref->State()) 

   973 		{

   974 	case ESpudUp:

   975 	case ESpudFlowOff:

   976 	case ESpudSuspended:

   977 	case ESpudFlowOffAndSuspended:

   978 		ref->SetState(ESpudWaitLinkDown);

   979 		SendContextDeleteEvent(aContextId);

   980 		ref->NifLink()->Stop(KErrConnectionTerminated, MNifIfNotify::EDisconnect);

   981         break;

   982         

   983     case ESpudStartingPrimaryLowerNif:

   984     	ref->SetState(ESpudWaitLinkDown);

   985     	SendPrimaryContextCreated(aContextId, KErrDisconnected);

   986     	SendContextDeleteEvent(aContextId);

   987     	ref->NifLink()->Stop(KErrConnectionTerminated, MNifIfNotify::EDisconnect);

   988         break;

   989         	        

   990 	case ESpudGettingNegQoS: // Context was activated. It is assumed that QoS retrieval would be cancelled by deletion.

   991 	case ESpudStartingSecondaryLowerNif:

   992 		ref->SetState(ESpudStartingSecondary);

   993 		FillInContextConfig(iTempContextConfig, aContextId);

   994 		SendContextActivateEvent(aContextId, iTempContextConfig, KErrDisconnected);

   995 		SendContextDeleteEvent(aContextId);

   996 		ref->NifLink()->Stop(KErrConnectionTerminated, MNifIfNotify::EDisconnect);

   997         break;

   998 		

   999 	case ESpudStartingPrimary: 

  1000 		// this should never happen

  1001 		SendPrimaryContextCreated(aContextId, KErrDisconnected);

  1002 		SendContextDeleteEvent(aContextId);

  1003 		DisposeOfBinder(ref);

  1004 		break;

  1005 	

  1006 	case ESpudStartingSecondary:

  1007 		// This should never happen, and may cause problems if it does because there could be

  1008 		// another outstanding request from GUQoS that never gets completed.

  1009 		__FLOG_0(_L("Network should not have deleted context in ESpudStartingSecondary state!"));

  1010 		// Fall through and treat the same as ESpudLinkDown

  1011 		

  1012 	case ESpudLinkDown:

  1013 		SendContextDeleteEvent(aContextId);

  1014 		DisposeOfBinder(ref);

  1015 		break;

  1016 	

  1017 	case ESpudWaitLinkDown:	

  1018 		DisposeOfBinder(ref);

  1019 		break;

  1020 		

  1021 	

  1022 	default:

  1023 		__FLOG_2(_L("Unexpected state %S(%d)"), SpudStateToText(ref->State()), ref->State());

  1024 		ASSERT(EFalse);

  1025 		break;

  1026 		}

  1027 	

  1028 	if(shutdownStarted) // Additional steps if we are shutting down as as result of this deletion.

  1029 		{

  1030 		SetTerminateError(KErrDisconnected); 

  1031 		// We don't reuse errorForGuqos, because we may want to keep Nifman errors and GUQoS errors separate.	

  1032 		if (AreQoSEventsEnabled())

  1033 			{

  1034 			// At this point we know that SPUD is about to shut down, because the last context 

  1035 			// was just deleted. We want to indicate to the upper layers early that

  1036 			// data can no longer be sent to SPUD.

  1037 								

  1038 			// Tell GUQoS to stop bothering SPUD.

  1039 			// GUQoS returns the favour by turning off the NIF events within this very call.

  1040 			// This means we send KNetworkInterfaceDown only once.

  1041 			// *******************************************************************************************

  1042 			// N.B.: "DEF055691 	GUQoS crashes at shutdown": This defect results in GUQoS crash if the stack

  1043     		// closes flows after the NIF proxy was deleted by GUQoS, as a result of KNetworkInterfaceDown event.

  1044     		// As a temporary workaround, this call is disabled, and KNetworkInterfaceDown event is signalled only

  1045     		// from the destructor. Once this defect is fixed, the following line must be uncommented: 

  1046     		// SendNetworkStatusEvent(KNetworkInterfaceDown, RPacketService::EStatusUnattached);

  1047 			//**********************************************************************************************

  1048 			}	

  1049 		}	

  1050 	}

  1051 

  1052 void CSpudMan::HandleSecondaryContextCreatedEvent(TContextId aContextId, TInt aError)

  1053 	{

  1054 	CSpudBinderRef* ref = NULL;

  1055 	TRAPD(rc, ref = iBindMan->GetRefL(aContextId));

  1056 	if (rc == KErrNone)

  1057 		{

  1058 		ASSERT(ref->IsBound());

  1059 		__FLOG_4(_L("Network created secondary context[%d] in state %S(%d). Creation error=%d "),aContextId, SpudStateToText(ref->State()), ref->State(), aError);

  1060 		if (ref->State() != ESpudStartingSecondary)

  1061 			{

  1062 			__FLOG_3(_L("KSecondaryContextCreated context %d is in unexpected state %S(%d)"),

  1063 			         aContextId, SpudStateToText(ref->State()), ref->State());

  1064 			}

  1065 		ref = ref;	// Eliminate compiler warning in release builds

  1066 		

  1067 		// Make sure context was created successfully

  1068 		rc = aError;

  1069 		if(KErrNone != rc) // Creation failed: we don't have the context, only the binder. Delete it.

  1070 			{

  1071 			DisposeOfBinder(ref);

  1072 			}

  1073 		}

  1074 	SendSecondaryContextCreated(aContextId, rc);

  1075 	}

  1076 

  1077 void CSpudMan::HandleContextActivateEvent(TContextId aContextId, TInt aError)

  1078 	{

  1079 	CSpudBinderRef* ref = NULL;

  1080 	TRAPD(rc, ref = iBindMan->GetRefL(aContextId));

  1081 	if (rc == KErrNone)

  1082 		{

  1083 		// Make sure context was activated successfully

  1084 		rc = aError;

  1085 	

  1086 		ASSERT(ref->IsBound());

  1087 		__FLOG_3(_L("context %d is in state %S(%d)"), aContextId, SpudStateToText(ref->State()), ref->State());

  1088 		}

  1089 

  1090 	if (rc == KErrNone)

  1091 		{

  1092 		ASSERT(ref->State() == ESpudStartingSecondary);

  1093 		// Start the lower NIF

  1094 		rc = ref->NifLink()->Start(); 

  1095 		// Even if we get KErrNone here, we may still get LinkLayerDown with error later.

  1096 		__FLOG_2(_L("KContextActivateEvent: Start on lower NIF returned for Context[%d] returned error[%d]"),aContextId, rc);

  1097 		}

  1098 	

  1099 	if(KErrNone == rc) // Start OK.

  1100 		{

  1101 		

  1102 		ref->SetState(ESpudStartingSecondaryLowerNif);

  1103 		}

  1104 	else

  1105 		{

  1106 		// Error activating PDP context

  1107 		FillInContextConfig(iTempContextConfig, aContextId);

  1108 		SendContextActivateEvent(aContextId, iTempContextConfig, rc);

  1109 		}

  1110 	}

  1111 

  1112 void CSpudMan::HandleContextQoSSetEvent(TContextId aContextId, TInt aError)

  1113 	{

  1114 	// Notify GUQoS of success or failure

  1115     SendContextQoSSetEvent(aContextId, aError);

  1116 	}

  1117 

  1118 void CSpudMan::HandleContextTFTModifiedEvent(TContextId aContextId, TInt aError)

  1119 	{

  1120 	CSpudBinderRef* ref = NULL;

  1121 	TRAPD(rc, ref = iBindMan->GetRefL(aContextId));

  1122 	__ASSERT_ALWAYS(rc == KErrNone, Panic());

  1123 	ASSERT(ref->IsBound());

  1124 	__FLOG_3(_L("context %d is in state %S(%d)"), aContextId, SpudStateToText(ref->State()), ref->State());

  1125 	ref = ref;	// Eliminate compiler warning in release builds

  1126 

  1127 	// Notify GUQoS of success or failure

  1128 	TTFTOperationCode opCode;

  1129     iPdpFsmInterface.Get(aContextId, opCode);

  1130     SendContextTFTModifiedEvent(aContextId, opCode, aError);

  1131 	}

  1132 

  1133 void CSpudMan::HandleGetNegQoSEvent(TContextId aContextId, TInt aError)

  1134 	{