1 // Copyright (c) 2005-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 // Implementation file for the IP SubConnection Provider and its basic version.

    15 // 

    16 //

    17 

    18 /**

    19  @file ipscpr.cpp

    20 */

    21 

    22 #include <e32std.h>

    23 #include <e32test.h>

    24 #include <ecom/ecom.h>

    25 #include <implementationproxy.h>

    26 #include <es_prot.h>

    27 #include <cs_subconevents.h>

    28 #include <cs_subconparams.h>

    29 #include "ipscpr.h"

    30 #include "ipscprlog.h"

    31 #include "sblpextn.h"

    32 #include <ip_subconparams.h>

    33 

    34 #ifndef BASIC_IPSCPR

    35 #include "pfqos_stream.h"

    36 #include "ipscprlog.h"

    37 #include <ip_subconparams.h>

    38 #include "qos_msg.h"

    39 #include "pfqoslib.h"

    40 #include <networking/qoserr.h>

    41 

    42 #ifdef SYMBIAN_NETWORKING_UMTSR5  

    43 #include <networking/imsextn.h>

    44 #include <networking/sblpextn.h>

    45 #include <networking/umtsextn.h>

    46 #else

    47 #include <networking/umtsapi.h>

    48 #include <networking/sblpapi.h>

    49 #endif 

    50 // SYMBIAN_NETWORKING_UMTSR5 

    51 

    52 #endif

    53 

    54 #ifndef SYMBIAN_NETWORKING_3GPPDEFAULTQOS

    55 // need to ensure the original TUid of the factory class is used for implementions in this component

    56 #undef KSubConIPParamsUid

    57 #endif

    58 

    59 

    60 /**

    61 Data required for instantiating ECOM Plugin

    62 */

    63 const TImplementationProxy ImplementationTable[] =

    64 	{

    65 	IMPLEMENTATION_PROXY_ENTRY(KSubConnectionProviderImplementationUid, CIpSubConnectionProviderFactory::NewL),

    66 	IMPLEMENTATION_PROXY_ENTRY(KSubConIPParamsUid, CSubConIPExtensionParamsFactory::NewL)

    67 	};

    68 

    69 

    70 /**

    71 ECOM Implementation Factory

    72 */

    73 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    74     {

    75     aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    76 

    77     return ImplementationTable;

    78     }

    79 

    80 

    81 /**

    82 Plugin Implementation

    83 */

    84 

    85 

    86 CIpSubConnectionProviderFactory* CIpSubConnectionProviderFactory::NewL(TAny* aConstructionParameters)

    87 /**

    88 Constructs a IP Connection Provider Factory

    89 

    90 @param aConstructionParameters construction data passed by ECOM

    91 

    92 @return pointer to a constructed factory

    93 */

    94 	{

    95 	CIpSubConnectionProviderFactory* ptr = new (ELeave) CIpSubConnectionProviderFactory(KIPConnectionProviderFactoryId, *(reinterpret_cast<CSubConnectionFactoryContainer*>(aConstructionParameters)));

    96 	return ptr;

    97 	}

    98 

    99 

   100 CIpSubConnectionProviderFactory::CIpSubConnectionProviderFactory(TUint aFactoryId, CSubConnectionFactoryContainer& aParentContainer)

   101 	: CSubConnectionProviderFactoryBase(aFactoryId, aParentContainer)

   102 /**

   103 IP SubConnection Provider Factory Constructor

   104 

   105 @param aFactoryId ECOM Implementation Id

   106 @param aParentContainer Object Owner

   107 */

   108 	{

   109 	}

   110 

   111 

   112 CIpSubConnectionProviderFactory::~CIpSubConnectionProviderFactory()

   113 /**

   114 IP SubConnection Provider Factory Destructor

   115 */

   116 	{

   117 	}

   118 

   119 

   120 CSubConnectionProviderBase* CIpSubConnectionProviderFactory::DoCreateProviderL(CConnectionProviderBase& aConnProvider, RSubConnection::TSubConnType aType)

   121 /**

   122 Factory Function that either creates a new SubConnection Provider or attaches

   123 to the default Provider.  The type of creation can be either RSubConnection::ECreateNew

   124 or RSubConnection::EAttachToDefault.

   125 

   126 Use of other types will cause the factory to leave with KErrNotSupported.

   127 

   128 @param aConnProvider Associated Connection Provider

   129 @param aType Type of SubConnection Provider Creation.

   130 */

   131 	{

   132 	CSubConnectionProviderBase* p = NULL;

   133 	switch (aType)

   134 		{

   135 #ifdef SYMBIAN_NETWORKING_3GPPDEFAULTQOS

   136 		case RSubConnection::EAttachToDefault:

   137 			p = new(ELeave)CDefaultSubConnectionProvider(*this, aConnProvider, aType);

   138 			break;

   139 #ifdef BASIC_IPSCPR

   140 		case RSubConnection::ECreateNew:

   141             // The Basic IPSCPR, itself, by definition, doesn't support secondary contexts.

   142             // Ideally it should defer to the transport layer provider as for primary contexts...

   143             //        

   144 			User::Leave(KErrNotSupported);

   145 			break;

   146 #else

   147 		case RSubConnection::ECreateNew:

   148 			p = CIpSubConnectionProvider::NewL(*this, aConnProvider);

   149 			break;

   150 #endif // BASIC_IPSCPR

   151 #else

   152 		case RSubConnection::ECreateNew:

   153 			p = CIpSubConnectionProvider::NewL(*this, aConnProvider);

   154 			break;

   155 		case RSubConnection::EAttachToDefault:

   156 			p = new(ELeave)CDefaultSubConnectionProvider(*this, aConnProvider);

   157 			break;

   158 #endif // SYMBIAN_NETWORKING_3GPPDEFAULTQOS

   159 		default:

   160 			{

   161 			User::Leave(KErrNotSupported);

   162 			}

   163 		};

   164 	return p;

   165 	}

   166 

   167 

   168 #ifndef BASIC_IPSCPR

   169 

   170 /**

   171 Provider Implementation

   172 */

   173 

   174 

   175 CIpSubConnectionProvider* CIpSubConnectionProvider::NewL(CIpSubConnectionProviderFactory& aFactory, CConnectionProviderBase& aConnProvider)

   176 /**

   177 Construct a new IP SubConnection Provider Object

   178 

   179 @param aFactory factory that create this object

   180 @param aConnProvider Connection Provider associated with this object

   181 */

   182 	{

   183 	CIpSubConnectionProvider* ptr = new (ELeave) CIpSubConnectionProvider(aFactory, aConnProvider);

   184 

   185     CleanupStack::PushL(ptr);

   186     ptr->ConstructL();

   187     CleanupStack::Pop();

   188 

   189 	return ptr;

   190 	}

   191 

   192 

   193 CIpSubConnectionProvider::CIpSubConnectionProvider(CIpSubConnectionProviderFactory& aFactory, CConnectionProviderBase& aConnProvider)

   194 	: CEmptySubConnectionProvider(aFactory, aConnProvider)

   195 	, iChannelId(-1)

   196 	, iPrtExtensions(_FOFF(CExtensionBase,iLink))

   197 	, iParametersSet(EFalse)

   198 /**

   199 IP SubConnection Provider Constructor

   200 

   201 @param aFactory factory that create this object

   202 @param aConnProvider Connection Provider associated with this object

   203 */

   204 	{

   205 		__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tCIpSubConnectionProvider() [MConnectionDataClient=%08x]"),

   206 		   this, (MConnectionDataClient*)this));

   207 	}

   208 

   209 

   210 CIpSubConnectionProvider::~CIpSubConnectionProvider()

   211 /**

   212 IP SubConnection Provider Destructor

   213 */

   214 	{

   215 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Destruct [%08x]"), this));

   216 

   217 	if( iChannelId >= 0 ) // Only send a Close if have opened a channel

   218 		{

   219 		TRAPD(ret,SendCloseL());

   220 		if( ret != KErrNone )

   221 			{

   222 			__IPCPRLOG(IpCprLog::Printf(_L("SendCloseL left with error: %d"), ret));

   223 			}

   224 		}

   225 

   226 	if( iWriter )

   227 		{

   228 		iWriter->Cancel();

   229 		delete iWriter;

   230 		iWriter = NULL;

   231 		}

   232 

   233 	if( iReader )

   234 		{

   235 		iReader->Cancel();

   236 		delete iReader;

   237 		iReader = NULL;

   238 		}

   239 

   240 	delete iPrtParameters;

   241 	delete iAsyncWriter;

   242 	ResetPrtExtensions();

   243 

   244 	iSocket.Close();

   245 	}

   246 

   247 

   248 void CIpSubConnectionProvider::ConstructL()

   249 /**

   250 IP SubConnection Provider Second Phase Constructor

   251 */

   252 	{

   253 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Construct [%08x]"), this));

   254 

   255 	// Open a connection to the QoS PRT

   256     _LIT(KDescPfqos, "pfqos");

   257 

   258 #ifdef SYMBIAN_NETWORKING_3GPPDEFAULTQOS

   259     // If we couldn't open pipe to QoS framework then it is not supported

   260     TInt ret = iSocket.Open(KDescPfqos);

   261     if(ret == KErrNotFound)

   262     {

   263     	User::Leave(KErrNotSupported);

   264     }

   265     else if (ret != KErrNone)

   266     {

   267     	User::Leave(ret);

   268     }

   269 #else

   270     User::LeaveIfError(iSocket.Open(KDescPfqos));

   271 #endif

   272     iUid = RProcess().Type();

   273 

   274 	iReader = CQoSMsgReader::NewL(this,	 iSocket);

   275 	iWriter = CQoSMsgWriter::NewL(this, iSocket);

   276 	iAsyncWriter = CAsyncWriter::NewL(iWriter);

   277 

   278 	/** Create the CQoSParameters to hold the Qos

   279 	* and Extension Parameters. The values will initially

   280 	be set to default

   281 	*/

   282 	iPrtParameters = new (ELeave) CQoSParameters;

   283 	// Set Default Uplink Parameters

   284 	iPrtParameters->SetUpLinkMaximumBurstSize(3000);  // for TokenBucketSizeUplink

   285 	iPrtParameters->SetUpLinkMaximumPacketSize(1500);	// for MaxPacketSizeUplink

   286 	iPrtParameters->SetUplinkBandwidth(1500);	// for TokenRateUplink

   287 	iPrtParameters->SetUpLinkAveragePacketSize(1500); // for MinimumPolicedUnitUplink

   288 	iPrtParameters->SetUpLinkPriority(KQoSLowestPriority); // for PriorityUplink

   289 	iPrtParameters->SetUpLinkDelay(0); // for DelayUplink

   290 	// Set Default Downlink parameters

   291 	iPrtParameters->SetDownLinkMaximumBurstSize(3000); // for TokenBucketSizeDownlink

   292 	iPrtParameters->SetDownLinkMaximumPacketSize(1500); // for MaxPacketSizeDownlink

   293 	iPrtParameters->SetDownlinkBandwidth(1500); // for TokenRateDownlink

   294 	iPrtParameters->SetDownLinkAveragePacketSize(1500); // for MinimumPolicedUnitDownlink

   295 	iPrtParameters->SetDownLinkPriority(KQoSLowestPriority); // for PriorityDownlonk

   296 	iPrtParameters->SetDownLinkDelay(0); // for DelayDownlink

   297 

   298 	iPrtParameters->SetAdaptMode(EFalse);

   299 //	iPrtParameters->SetHeaderMode(???);

   300 //	User::LeaveIfError(iPrtParameters->SetName(name));

   301 	}

   302 

   303 

   304 TAny* CIpSubConnectionProvider::FetchInterfaceInstanceL(CSubConnectionProviderBase& /*aProvider*/, const STypeId& aTid)

   305 	{

   306 	return (aTid == STypeId::CreateSTypeId(KConnectionClientExtUid,EConnectionEnumerateClients)) ? static_cast<MConnectionEnumerateClients*>(this) : NULL;

   307 	}

   308 

   309 void CIpSubConnectionProvider::DoDataClientJoiningL(MSubConnectionDataClient& aDataClient)

   310 /**

   311 Function called by Connection Provider when a socket is to be added to a QoS Flow

   312 

   313 @param aDataClient Data Client to add to the QoS Channel

   314 */

   315 	{

   316 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tDoDataClientJoiningL() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient));

   317 

   318 	// Can only join to a channel once it has been successfully routed

   319 	// Can only open/create/join the channel once the connection has been established

   320 	const TSockAddr* srcAddr = NULL;

   321 	const TSockAddr* dstAddr = NULL;

   322 	const TDesC8* connInfo;

   323 	if(aDataClient.ReadAddressInformation(srcAddr, dstAddr, connInfo) == KErrNone)

   324 		{

   325 		if( srcAddr == NULL || srcAddr->Family() == KAFUnspec )

   326 			{

   327 			__IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));

   328 			User::Leave( KErrNotReady );

   329 			}

   330 

   331 		if( dstAddr == NULL || dstAddr->Family() == KAFUnspec )

   332 			{

   333 			__IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));

   334 			User::Leave( KErrNotReady );

   335 			}

   336 

   337 		if( connInfo == NULL )

   338 			{

   339 			__IPCPRLOG(IpCprLog::Printf(_L("Connection Information not defined")));

   340 			User::Leave( KErrNotReady );

   341 			}

   342 

   343 		TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();

   344 		TUint32 iapId = (*connInfoBuf)().iIapId;

   345 

   346 		if( iChannelId >= 0 )

   347 			{

   348 			SendJoinL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId());

   349 			}

   350 		else

   351 			{

   352 			SendCreateL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId());

   353 			}

   354 		}

   355 	}

   356 

   357 

   358 void CIpSubConnectionProvider::DoDataClientLeaving(MSubConnectionDataClient& aDataClient)

   359 /**

   360 Function called by Connection Provider when a socket is to be removed from a QoS Flow

   361 

   362 @param aDataClient Data Client to remove from the QoS Channel

   363 */

   364 	{

   365 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider [this=%08x]:\tDoDataClientLeaving() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient));

   366 

   367 	// Can only leave on a routed conection that has been successfully

   368 	// attached to a QoS Channel.  Otherwise we cannot leave

   369 	const TSockAddr* srcAddr = NULL;

   370 	const TSockAddr* dstAddr = NULL;

   371 	const TDesC8* connInfo;

   372 	TInt err = aDataClient.ReadAddressInformation(srcAddr, dstAddr, connInfo);

   373 	if( err != KErrNone )

   374 		{

   375 		__IPCPRLOG(IpCprLog::Printf(_L("Unable to read Address Information")));

   376 		return;

   377 		}

   378 

   379 	if( srcAddr == NULL || srcAddr->Family() == KAFUnspec )

   380 		{

   381 		__IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));

   382 		return;

   383 		}

   384 

   385 	if( dstAddr == NULL || dstAddr->Family() == KAFUnspec )

   386 		{

   387 		__IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));

   388 		return;

   389 		}

   390 

   391 	if( connInfo == NULL )

   392 		{

   393 		__IPCPRLOG(IpCprLog::Printf(_L("Connection Information not defined")));

   394 		return;

   395 		}

   396 

   397 	TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();

   398 	TUint32 iapId = (*connInfoBuf)().iIapId;

   399 

   400 	if( iChannelId >= 0 )

   401 		{

   402 		TRAPD(ret, SendLeaveL((TInetAddr)*srcAddr, (TInetAddr)*dstAddr, iapId, aDataClient.ProtocolId()));

   403 		if (ret != KErrNone)

   404 			{

   405 			__IPCPRLOG(IpCprLog::Printf(_L("SendLeaveL left with err=%d"), ret));

   406 			}

   407 		}

   408 	else

   409 		{

   410 		__IPCPRLOG(IpCprLog::Printf(_L("Attempted to leave on an unconnected channel")));

   411 		}

   412 	}

   413 

   414 

   415 void CIpSubConnectionProvider::DoSourceAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aSource*/)

   416 /**

   417 Function called by Connection Provider when the source address on a data client is set

   418 

   419 @param aDataClient Data Client affected

   420 @param aSource Source Address

   421 */

   422 	{

   423 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoSourceAddressUpdate [%08x]"), this));

   424 	// Not Interested in either souce or destination updates; wait until connected

   425 	}

   426 

   427 

   428 void CIpSubConnectionProvider::DoDestinationAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aDestination*/)

   429 /**

   430 Function called by Connection Provider when the destination address on a data client is set

   431 

   432 @param aDataClient Data Client affected

   433 @param aDestination Destination Address

   434 */

   435 	{

   436 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoDestinationAddressUpdate [%08x]"), this));

   437 	// Not Interested in either souce or destination updates; wait until connected

   438 	}

   439 

   440 

   441 void CIpSubConnectionProvider::DoDataClientRouted(MSubConnectionDataClient& aDataClient, const TSockAddr& aSource, const TSockAddr& aDestination, const TDesC8& aConnectionInfo)

   442 /**

   443 Function called by Connection Provider when the connection has been established

   444 

   445 @param aDataClient Data Client affected

   446 @param aSource Source Address

   447 @param aDestination Destination Address

   448 @param aConnectionInfo Connection Data

   449 */

   450 	{

   451 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoDestinationAddressUpdate [%08x]"), this));

   452 

   453 	TConnectionInfoBuf* connInfo = (TConnectionInfoBuf*)aConnectionInfo.Ptr();

   454 	TUint32 iapId = (*connInfo)().iIapId;

   455 

   456   	if( aSource.Family() != KAFUnspec && aDestination.Family() != KAFUnspec)

   457 		{

   458 		// If already have a open channel add this socket.  o/w create a new channel

   459 		if( iChannelId >= 0 )

   460 			{

   461 			TRAPD(ret,SendJoinL((TInetAddr)aSource, (TInetAddr)aDestination, iapId, aDataClient.ProtocolId()));

   462 			if( ret != KErrNone )

   463 				{

   464 				__IPCPRLOG(IpCprLog::Printf(_L("SendJoinL left with error: %d"), ret));

   465 				}

   466 			}

   467 		else

   468 			{

   469 			TRAPD(ret,SendCreateL((TInetAddr)aSource, (TInetAddr)aDestination, iapId, aDataClient.ProtocolId()));

   470 			if( ret != KErrNone )

   471 				{

   472 				__IPCPRLOG(IpCprLog::Printf(_L("SendCreateL left with error: %d"), ret));

   473 				}

   474 			}

   475 		}

   476 	else

   477 		{

   478 		__IPCPRLOG(IpCprLog::Printf(_L("Data Client Routed contains invalid source or dest address")));

   479 		}

   480 	}

   481 

   482 

   483 void CIpSubConnectionProvider::DoParametersAboutToBeSetL(CSubConParameterBundle& aParameterBundle)

   484 /**

   485 Function called by the Connection Provider before the QoS Parameters are set by the client

   486 

   487 @param aParameterBundle Container holding pending QoS Parameters

   488 */

   489 	{

   490 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoParametersAboutToBeSetL [%08x]"), this));

   491 

   492 	iParameterRelease = KParameterRelInvalid;

   493 	ConvertParametersFromESockL( aParameterBundle );

   494 	iParametersSet = ETrue;

   495 

   496   	if(iChannelId >= 0)

   497 		{

   498 		SendSetQoSL();

   499 		}

   500 	}

   501 

   502 

   503 TInt CIpSubConnectionProvider::DoControl(TUint /*aOptionLevel*/, TUint /*aOptionName*/, TDes8& /*aOption*/)

   504 /**

   505 @param aOptionLevel

   506 @param aOptionName

   507 @param aOption

   508 */

   509 	{

   510 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::DoControl [%08x]"), this));

   511 

   512 	return KErrNotSupported;

   513 	}

   514 

   515 

   516 void CIpSubConnectionProvider::DoStartL()

   517 	{

   518 	}

   519 

   520 void CIpSubConnectionProvider::DoStop()

   521 	{

   522 	}

   523 

   524 CSubConnectionProviderBase* CIpSubConnectionProvider::DoNextLayer()

   525 	{

   526 	return NULL;

   527 	}

   528 

   529 CConnDataTransfer& CIpSubConnectionProvider::DoDataTransferL()

   530 	{

   531 	User::Leave(KErrNotSupported);

   532 	//unreachable code

   533 	return iNextLayer->DataTransferL();

   534 //	return *((CConnDataTransfer*)this);

   535 	}

   536 

   537 //MConnectionDataClient

   538 void CIpSubConnectionProvider::ConnectionGoingDown(CConnectionProviderBase& /*aConnProvider*/)

   539 	{

   540 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ConnectionGoingDown [%08x]"), this));

   541 	iConnectionProvider = NULL;

   542 	DeleteMeNow();

   543 	}

   544 

   545 void CIpSubConnectionProvider::Notify(TNotify /*aNotifyType*/,  CConnectionProviderBase* /*aConnProvider*/, TInt /*aError*/, const CConNotificationEvent* /*aConNotificationEvent*/)

   546 	{

   547 	}

   548 

   549 void CIpSubConnectionProvider::AttachToNext(CSubConnectionProviderBase* /*aSubConnProvider*/)

   550 	{

   551 	}

   552 

   553 

   554 

   555 void CIpSubConnectionProvider::SendOpenExistingL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)

   556 /**

   557 Sends a Message to QoS PRT to open a QoS Channel

   558 

   559 @param aSrcAddr Source Address

   560 @param aDstAddr Destination Address

   561 @param aIapId IAP Id

   562 @param aProtocolId Protocol Id

   563 */

   564     {

   565 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosOpenExistingChannel")));

   566 

   567     CQoSMsg* msg = CQoSMsg::NewL(EPfqosOpenExistingChannel);

   568     msg->AddConnInfo(aProtocolId, iUid, aIapId);

   569     msg->AddSrcAddr(aSrcAddr);

   570     msg->AddDstAddr(aDstAddr);

   571     msg->AddChannel(0);

   572 

   573     iWriter->Send(msg);

   574     }

   575 

   576 

   577 void CIpSubConnectionProvider::SendCreateL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)

   578 /**

   579 Sends a Message to QoS PRT to create a QoS Channel

   580 

   581 @param aSrcAddr Source Address

   582 @param aDstAddr Destination Address

   583 @param aIapId IAP Id

   584 @param aProtocolId Protocol Id

   585 */

   586     {

   587 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosCreateChannel")));

   588 

   589     CQoSMsg* msg = CQoSMsg::NewL(EPfqosCreateChannel);

   590     msg->AddConnInfo(aProtocolId, iUid, aIapId);

   591     msg->AddSrcAddr(aSrcAddr);

   592     msg->AddDstAddr(aDstAddr);

   593     msg->AddChannel(0);

   594 

   595     TQoSParameters qosParams;

   596     ConvertCQoSIntoTQoSParamsL(qosParams);

   597 	msg->AddQoSParameters(qosParams);

   598     msg->AddExtensionPolicy(iPrtExtensions);

   599 	//Now we need to write to the qos.prt asynchronously. This becuase the TCP/IP stack in CIp6Flow::Connect() calls Bearer() before RefreshFlow()

   600     iAsyncWriter->Send(msg);

   601     }

   602 

   603 

   604 void CIpSubConnectionProvider::SendCloseL()

   605 /**

   606 Sends a Message to QoS PRT to close a QoS Channel

   607 */

   608 	{

   609 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosDeleteChannel")));

   610 

   611     CQoSMsg* msg = CQoSMsg::NewL(EPfqosDeleteChannel);

   612     msg->AddChannel(iChannelId);

   613 

   614     iWriter->Send(msg);

   615 	}

   616 

   617 

   618 void CIpSubConnectionProvider::SendJoinL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)

   619 /**

   620 Sends a Message to QoS PRT to add a socket to a QoS Channel

   621 

   622 @param aSrcAddr Source Address

   623 @param aDstAddr Destination Address

   624 @param aIapId IAP Id

   625 @param aProtocolId Protocol Id

   626 */

   627     {

   628 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosJoin")));

   629 

   630     CQoSMsg* msg = CQoSMsg::NewL(EPfqosJoin);

   631     msg->AddConnInfo(aProtocolId, iUid, aIapId);

   632     msg->AddSrcAddr(aSrcAddr);

   633     msg->AddDstAddr(aDstAddr);

   634     msg->AddChannel(iChannelId);

   635 

   636     iWriter->Send(msg);

   637     }

   638 

   639 

   640 void CIpSubConnectionProvider::SendLeaveL(const TInetAddr &aSrcAddr, const TInetAddr &aDstAddr, TUint32 aIapId, TUint32 aProtocolId)

   641 /**

   642 Sends a Message to QoS PRT to remove a socket from a QoS Channel

   643 

   644 @param aSrcAddr Source Address

   645 @param aDstAddr Destination Address

   646 @param aIapId IAP Id

   647 @param aProtocolId Protocol Id

   648 */

   649     {

   650 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosLeave")));

   651 

   652     CQoSMsg* msg = CQoSMsg::NewL(EPfqosLeave);

   653     msg->AddConnInfo(aProtocolId, iUid, aIapId);

   654     msg->AddSrcAddr(aSrcAddr);

   655     msg->AddDstAddr(aDstAddr);

   656     msg->AddChannel(iChannelId);

   657 

   658     iWriter->Send(msg);

   659     }

   660 

   661 

   662 

   663 void CIpSubConnectionProvider::SendSetQoSL()

   664 /**

   665 Sends Message to QoS PRT to update the parameters for a QoS Channel

   666 */

   667     {

   668 	__IPCPRLOG(IpCprLog::Printf(_L("Sending PRT Msg: EPfqosConfigChannel")));

   669 

   670     CQoSMsg* msg = CQoSMsg::NewL(EPfqosConfigChannel);

   671     msg->AddChannel(iChannelId);

   672 

   673     TQoSParameters qosParams;

   674     ConvertCQoSIntoTQoSParamsL(qosParams);

   675     msg->AddQoSParameters(qosParams);

   676     msg->AddExtensionPolicy(iPrtExtensions);

   677 

   678     iWriter->Send(msg);

   679     }

   680 

   681 

   682 void CIpSubConnectionProvider::ProcessPRTMsg(TPfqosMessage& aMsg)

   683 /**

   684 Process Messages sent from the PRT to the SubConnection Provider

   685 Messages are either replies or events

   686 

   687 @param aMsg the message from the PRT

   688 */

   689 	{

   690 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTMsg [%08x]"), this));

   691 

   692     if( aMsg.iBase.iMsg == NULL )

   693     	{

   694 		__IPCPRLOG(IpCprLog::Printf(_L("Received malformed message from PRT")));

   695     	}

   696     else

   697     	{

   698 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Msg: %d"), aMsg.iBase.iMsg->pfqos_msg_type));

   699 	    switch(aMsg.iBase.iMsg->pfqos_msg_type)

   700 			{

   701 		case EPfqosEvent:

   702 			{

   703 			TRAPD(ret, ProcessPRTEventL(aMsg) );

   704 			if( ret != KErrNone )

   705 				{

   706 				__IPCPRLOG(IpCprLog::Printf(_L("ProcessPRTEventL left with error: %d"), ret));

   707 				}

   708 			}

   709 			break;

   710 

   711 		case EPfqosUpdate:

   712 		case EPfqosDelete:

   713 		case EPfqosAdd:

   714 		case EPfqosGet:

   715 		case EPfqosReject:

   716 		case EPfqosDump:

   717 		case EPfqosConfigure:

   718 		case EPfqosJoin:

   719 		case EPfqosLeave:

   720 		case EPfqosCreateChannel:

   721 		case EPfqosOpenExistingChannel:

   722 		case EPfqosDeleteChannel:

   723 		case EPfqosConfigChannel:

   724 		case EPfqosLoadFile:

   725 		case EPfqosUnloadFile:

   726 			{

   727 			TRAPD(ret, ProcessPRTReplyL(aMsg) );

   728 			if( ret != KErrNone )

   729 				{

   730 				__IPCPRLOG(IpCprLog::Printf(_L("ProcessPRTReplyL left with error: %d"), ret));

   731 				}

   732 			}

   733 		    break;

   734 

   735 		default:

   736 			__IPCPRLOG(IpCprLog::Printf(_L("Received Unknown PRT Msg: %d"), aMsg.iBase.iMsg->pfqos_msg_type));

   737 		    break;

   738 			}

   739     	}

   740 	}

   741 

   742 

   743 void CIpSubConnectionProvider::ProcessPRTEventL(TPfqosMessage& aMsg)

   744 /**

   745 Process Events sent from the PRT to the SubConnection Provider

   746 

   747 @param aMsg the message from the PRT

   748 */

   749 	{

   750 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTEventL [%08x]"), this));

   751 

   752 	// Only interested in Channel Events

   753     if (aMsg.iEvent.iExt == NULL || aMsg.iFlowSpec.iExt == NULL || aMsg.iChannel.iExt == NULL)

   754     	{

   755 		__IPCPRLOG(IpCprLog::Printf(_L("Received malformed event message from PRT")));

   756     	return;

   757     	}

   758 

   759 	MSubConnectionDataClient* client = NULL;

   760 	TInt ret = DetermineClient(aMsg, client);

   761 	if( ret != KErrNone || client == NULL )

   762 		{

   763 		__IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message.  Error=%d"), ret));

   764 		}

   765 

   766 	switch (aMsg.iEvent.iExt->event_type)

   767 		{

   768 	case KPfqosEventFailure:

   769 		{

   770 /*		

   771 		EQoSOk,

   772     EQoSPolicyExists = -5119,       //< -5119 Policy exists in database

   773     EQoSNoModules,					//< -5118 No QoS modules available

   774     EQoSInterface,			        //< -5117 Flows are using different interfaces

   775 	EQoSModules,					//< -5116 Flows use different QoS modules

   776 	EQoSModuleLoadFailed,			//< -5115 Loading of QoS module failed

   777 	EQoSMessageCorrupt,				//< -5114 Pfqos message corrupted

   778 	EQoSJoinFailure,				//< -5113 Join to QoS channel failed

   779 	EQoSLeaveFailure,				//< -5112 Leave from QoS channel failed

   780 	EQoSNoInterface,				//< -5111 Network interface deleted

   781 	EQoSChannelDeleted,				//< -5110 QoS channel deleted

   782 	EQoSDowngradeForced				//< -5109 QoS parameters downgraded by administrative policy

   783 */

   784 		CSubConNotificationEvent* event = NULL;

   785 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventFailure.  Error=%d"),aMsg.iBase.iMsg->pfqos_msg_errno));

   786 

   787 #if defined(QOS_ERROR_REPORTING) //Awaiting code delivery for qos and guqos to support this functionality 		

   788 		switch(aMsg.iBase.iMsg->pfqos_msg_errno)

   789 			{

   790 				case EQoSJoinFailure:

   791 				

   792 					if( client )

   793 						{

   794 						__IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));

   795 						client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);

   796 						}

   797 					break;

   798 				

   799 				case EQoSLeaveFailure:

   800 					if( client )

   801 						{

   802 						__IPCPRLOG(IpCprLog::Printf(_L("Leave failed Event")));

   803 						//We don't particularly care that it failed - just pretend that it was successful

   804 						client->LeaveComplete(*this);

   805 						}

   806 					break;

   807 				case EQoSNoInterface:

   808 				case EQoSChannelDeleted:

   809 					{

   810 					CSubConGenEventSubConDown* scde = CSubConGenEventSubConDown::NewL();

   811 					scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);

   812 					event = scde;

   813 					iChannelId = -1;	

   814 					break;

   815 					}

   816 				case EQoSDowngradeForced:

   817 					{

   818 					event = CSubConGenEventParamsChanged::NewL();

   819 					break;

   820 					}

   821 					

   822 				case EQoSChannelFailed:

   823 					if( client )

   824 						{

   825 						__IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));

   826 						client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);

   827 						}

   828 					// no break here we want to continue into the next case statement;

   829 				case EQoSParamsRejected:

   830 					{

   831 					CSubConGenEventParamsRejected* scde = CSubConGenEventParamsRejected::NewL();

   832 					scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);

   833 					scde->SetFamilyId(KSubConQoSFamily);

   834 					event = scde;

   835 					break;	

   836 					}

   837 

   838 				default:

   839 					__IPCPRLOG(IpCprLog::Printf(_L("Unknown event sent ")));			

   840 			};

   841 #else

   842 			if( client )

   843 				{

   844 				__IPCPRLOG(IpCprLog::Printf(_L("Join failed Event")));

   845 				client->JoinFailed(*this,aMsg.iBase.iMsg->pfqos_msg_errno);

   846 				CSubConGenEventParamsRejected* scde = CSubConGenEventParamsRejected::NewL();

   847 				/**

   848 				There can be two set of parameters that are sent to QOS either as KSubConQoSFamily

   849 				or as KSubConAuthorisationFamily. Here we should differentiate, the QOS is rejected 

   850 				because of which parameter family. 

   851 				At present there is no indication comes from the lower layer why the QOS has failed, and in 

   852 				all the case the member *aMsg.iBase.iMsg->pfqos_msg_type* will return *EPfQoSReject*.

   853 				

   854 				At the time of writing this code any differentiation method was not available to differentiate

   855 				between events. i.e whether the event is SBLP or UMTS events. So this has not been done.

   856 				This needs to be done when the TPfqosMessage will have the differentiation

   857 				*/

   858 				scde->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);

   859 				scde->SetFamilyId(KSubConQoSFamily);

   860 				event = scde;

   861 				}			

   862 #endif

   863 		

   864 		// Setting QoS Parameters Failed

   865 		/**

   866 		There can be two set of parameters that are sent to QOS either as KSubConQoSFamily

   867 		or as KSubConAuthorisationFamily. Here we should differentiate, the QOS is rejected

   868 		because of which parameter family.

   869 		At present there is no indication comes from the lower layer why the QOS has failed, and in

   870 		all the case the member *aMsg.iBase.iMsg->pfqos_msg_type* will return *EPfQoSReject*.

   871 

   872 		At the time of writing this code any differentiation method was not available to differentiate

   873 		between events. i.e whether the event is SBLP or UMTS events. So this has not been done.

   874 		This needs to be done when the TPfqosMessage will have the differentiation

   875 		*/

   876 		if (event)

   877 			{

   878 				

   879 			NotifyClientEvent(*event);

   880 			delete event;

   881 			}

   882 		}

   883 	    break;

   884 

   885 	case KPfqosEventConfirm:

   886 		{

   887 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventConfirm")));

   888 

   889 		// Setting QoS Parameters OK

   890 		CSubConGenEventParamsGranted* event = CSubConGenEventParamsGranted::NewL();

   891 		ConvertParametersFromQOSL(aMsg, event);

   892 

   893 		NotifyClientEvent(*event);

   894 		delete event;

   895 

   896 		if( client != NULL )

   897 			{

   898 			client->JoinComplete(*this);

   899 			}

   900 		}

   901 	    break;

   902 

   903 	case KPfqosEventAdapt:

   904 		{

   905 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventAdapt")));

   906 

   907 		// Available QoS Changed

   908 		CSubConGenEventParamsChanged* event = CSubConGenEventParamsChanged::NewL();

   909 		event->SetError(aMsg.iBase.iMsg->pfqos_msg_errno);

   910 		ConvertParametersFromQOSL(aMsg, event);

   911 

   912 		NotifyClientEvent(*event);

   913 		delete event;

   914 		}

   915 	    break;

   916 

   917 	case KPfqosEventJoin:

   918 		{

   919 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventJoin")));

   920 		if (aMsg.iBase.iMsg->pfqos_msg_errno)

   921 		   {

   922 		   ProcessPRTError( aMsg, aMsg.iBase.iMsg->pfqos_msg_errno );

   923 		   return;

   924 		   }

   925 

   926 

   927 		CSubConGenEventDataClientJoined* event = CSubConGenEventDataClientJoined::NewL();

   928 

   929 		if( client )

   930 			{

   931 			const TSockAddr* SrcAddr = NULL;

   932 			const TSockAddr* DstAddr = NULL;

   933 			const TDesC8* connInfo;

   934 			client->ReadAddressInformation(SrcAddr, DstAddr, connInfo);  // return can be would have errored above

   935 

   936 			TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();

   937 			TUint32 iapId = (*connInfoBuf)().iIapId;

   938 

   939 			event->SetSourceAddress( *SrcAddr );

   940 			event->SetDestAddress( *DstAddr );

   941 			event->SetIap( iapId );

   942 

   943 			client->JoinComplete(*this);

   944 			}

   945 

   946 		NotifyClientEvent(*event);

   947 		delete event;

   948 		}

   949 	    break;

   950 

   951 	case KPfqosEventLeave:

   952 		{

   953 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: KPfqosEventLeave")));

   954 	

   955 		CSubConGenEventDataClientLeft* event = CSubConGenEventDataClientLeft::NewL();

   956 

   957 		if( client )

   958 			{

   959 			const TSockAddr* SrcAddr = NULL;

   960 			const TSockAddr* DstAddr = NULL;

   961 			const TDesC8* connInfo;

   962 			client->ReadAddressInformation(SrcAddr, DstAddr, connInfo);  // return can be would have errored above

   963 

   964 			TConnectionInfoBuf* connInfoBuf = (TConnectionInfoBuf*)connInfo->Ptr();

   965 			TUint32 iapId = (*connInfoBuf)().iIapId;

   966 

   967 			event->SetSourceAddress( *SrcAddr );

   968 			event->SetDestAddress( *DstAddr );

   969 			event->SetIap( iapId );

   970 			}

   971 

   972 		NotifyClientEvent(*event);

   973 		delete event;

   974 		

   975 		if( client != NULL )

   976 			{

   977 			client->LeaveComplete(*this);

   978 			}

   979 		}

   980 	    break;

   981 

   982 	default:

   983 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Event: Unknown - %d"), aMsg.iEvent.iExt->event_type));

   984 	    break;

   985 		}

   986 	}

   987 

   988 void CIpSubConnectionProvider::ProcessPRTReplyL(TPfqosMessage& aMsg)

   989 /**

   990 Process Replies sent from the PRT to the SubConnection Provider

   991 

   992 @param aMsg the message from the PRT

   993 */

   994 	{

   995 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTReplyL [%08x]"), this));

   996 

   997 	if( aMsg.iChannel.iExt == NULL )

   998 		{

   999 		__IPCPRLOG(IpCprLog::Printf(_L("Received malformed reply message from PRT")));

  1000 		}

  1001 	else if( aMsg.iBase.iMsg->pfqos_msg_errno != KErrNone )

  1002     	{

  1003     	ProcessPRTError( aMsg, aMsg.iBase.iMsg->pfqos_msg_errno );

  1004     	}

  1005 	else

  1006     	{

  1007 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Reply: %d"), aMsg.iBase.iMsg->pfqos_msg_type));

  1008 

  1009 		MSubConnectionDataClient* client = NULL;

  1010 		TInt ret = DetermineClient(aMsg, client);

  1011 		if( ret != KErrNone || client == NULL )

  1012 			{

  1013 			__IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message.  Error=%d"),ret));

  1014 			}

  1015 

  1016 		switch (aMsg.iBase.iMsg->pfqos_msg_type)

  1017 			{

  1018 		case EPfqosOpenExistingChannel:

  1019 			iChannelId = aMsg.iChannel.iExt->channel_id;

  1020 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosOpenExistingChannel")));

  1021 			break;

  1022 

  1023 		case EPfqosCreateChannel:

  1024 			iChannelId = aMsg.iChannel.iExt->channel_id;

  1025 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosCreateChannel")));

  1026 			//Now you will expect to complete the join here. This will not work becuase

  1027 			//qos.prt send a reply before finishing the join down to the nif level

  1028 			//we will have to delay the response until the event is received

  1029 			break;

  1030 

  1031 		case EPfqosJoin:

  1032 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosJoin")));

  1033 			//Now you will expect to complete the join here. This will not work becuase

  1034 			//qos.prt send a reply before finishing the join down to the nif level

  1035 			//we will have to delay the response until the event is received

  1036 			break;

  1037 

  1038 		case EPfqosLeave:

  1039 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosLeave")));

  1040 			break;

  1041 

  1042 		case EPfqosConfigChannel:

  1043 			{

  1044 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosConfigChannel")));

  1045 			}

  1046 			break;

  1047 

  1048 		case EPfqosDeleteChannel:

  1049 			iChannelId = -1;

  1050 			__IPCPRLOG(IpCprLog::Printf(_L("Processing Reply for message: EPfqosDeleteChannel")));

  1051 			break;

  1052 

  1053 		default:

  1054 			__IPCPRLOG(IpCprLog::Printf(_L("Ignoring Reply for unknown message: %d"), aMsg.iBase.iMsg->pfqos_msg_type));

  1055 			break;

  1056 			}

  1057     	}

  1058 

  1059 	__IPCPRLOG(IpCprLog::Printf(_L("Provider=0x%x Channel=%d"), this, iChannelId));

  1060 	}

  1061 

  1062 

  1063 #ifdef _DEBUG

  1064 void CIpSubConnectionProvider::ProcessPRTError(TInt aMsgType, TInt __IPCPRLOG(aError))

  1065 /**

  1066 Process Errors that occur in communicating between the PRT and the

  1067 SubConnection Provider

  1068 

  1069 @param aMsgType the type of message that encountered the error

  1070 @param aError the error ththas occurred

  1071 */

  1072 	{

  1073 	switch (aMsgType)

  1074 		{

  1075 	case EPfqosOpenExistingChannel:

  1076 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosOpenExistingChannel"), aError));

  1077 		break;

  1078 

  1079 	case EPfqosCreateChannel:

  1080 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosCreateChannel"), aError));

  1081 		break;

  1082 

  1083 	case EPfqosDeleteChannel:

  1084 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosDeleteChannel"), aError));

  1085 		break;

  1086 

  1087 	case EPfqosJoin:

  1088 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosJoin"), aError));

  1089 		break;

  1090 

  1091 	case EPfqosLeave:

  1092 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosLeave"), aError));

  1093 		break;

  1094 

  1095 	case EPfqosConfigChannel:

  1096 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosConfigChannel"), aError));

  1097 		break;

  1098 

  1099    case  EPfqosEvent:

  1100 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on EPfqosEvent"), aError));

  1101 		break;

  1102 

  1103 	default:

  1104 		__IPCPRLOG(IpCprLog::Printf(_L("Received PRT Error %d on Unknown Message"), aError));

  1105 		break;

  1106 		}

  1107 	}

  1108 #endif

  1109 

  1110 

  1111 void CIpSubConnectionProvider::ProcessPRTError(TPfqosMessage& aMsg, TInt aError)

  1112 /**

  1113 Process Errors that occur in communicating between the PRT and the

  1114 SubConnection Provider

  1115 

  1116 @param aMsg the message from the PRT

  1117 @param aError the error ththas occurred

  1118 */

  1119 	{

  1120 	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ProcessPRTError [%08x]"), this));

  1121 

  1122 	if( aError != KErrNone)

  1123 		{

  1124 		TInt msgType = aMsg.iBase.iMsg->pfqos_msg_type;

  1125 

  1126 #ifdef _DEBUG

  1127 		ProcessPRTError(msgType, aError);

  1128 #endif

  1129 

  1130 		MSubConnectionDataClient* client = NULL;

  1131 		TInt ret = DetermineClient(aMsg, client);

  1132 		if( ret != KErrNone || client == NULL )

  1133 			{

  1134 			__IPCPRLOG(IpCprLog::Printf(_L("Could not determine DataClient from message.  Error=%d"),ret));