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

    17  @file SS_SAPSHIM.CPP

    18 */

    19 

    20 #define SYMBIAN_NETWORKING_UPS

    21 #include "ss_sapshim.h"

    22 

    23 #include <ss_std.h>

    24 #include <ss_glob.h>

    25 #include <comms-infras/ss_roles.h>

    26 #include <comms-infras/ss_log.h>

    27 #include <comms-infras/ss_subconnprov.h>

    28 #include <comms-infras/ss_connprov.h>

    29 #include <ss_protprov.h>

    30 #include <ss_sock.h>

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

    32 #include <in_sock.h> // KAfInet

    33 #include <elements/nm_messages_child.h>

    34 #include <elements/nm_messages_peer.h>

    35 

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

    37 #include <comms-infras/nifif_internal.h>

    38 

    39 #include <addressupdate.h>

    40 

    41 #include <comms-infras/ss_nodemessages_dataclient.h>

    42 #include <comms-infras/ss_nodemessages_flow.h>

    43 #include <comms-infras/ss_nodemessages_ipmessages.h>

    44 #include <comms-infras/ss_nodemessages_internal_esock.h>

    45 

    46 #include "ss_protopt.h"

    47 

    48 #ifdef SYMBIAN_NETWORKING_UPS

    49 #include <comms-infras/ss_upsaccesspointconfigext.h>

    50 #include <comms-infras/upsmessages.h>

    51 

    52 

    53 #ifdef _DEBUG

    54 // Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

    55 // (if it could happen through user error then you should give it an explicit, documented, category + code)

    56 _LIT(KSpecAssert_ESockSSocksspshm, "ESockSSocksspshm");

    57 #endif

    58 

    59 _LIT_SECURITY_POLICY_C1(KPolicyNetworkServices, ECapabilityNetworkServices);

    60 #endif

    61 

    62 using namespace ESock;

    63 using namespace Messages;

    64 using namespace MeshMachine;

    65 using namespace Factories;

    66 

    67 //CHostResolver specific functions this is to remove once we have app layer protocols

    68 //***************************************************************************************

    69 //also loo for iHostResolverNotify

    70 MLowerControl* CTransportFlowShim::GetControlL(const TDesC8& /*aProtocol*/)

    71     {

    72     return this;

    73     }

    74 

    75 TInt CTransportFlowShim::Control(TUint aLevel, TUint aName, TDes8& aOption)

    76     {

    77     return iLowerControl ? iLowerControl->Control(aLevel, aName, aOption) : KErrNotReady;

    78     }

    79 

    80 MLowerDataSender* CTransportFlowShim::BindL(const TDesC8& /*aProtocol*/, MUpperDataReceiver* aReceiver, MUpperControl* aControl)

    81     {

    82     if (aReceiver || iProvider || IsBoundToSession())

    83         {

    84         User::Leave(KErrInUse);

    85         }

    86     iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TActive().CRef());

    87     iHostResolverNotify = aControl;

    88     return this;

    89     }

    90 

    91 void CTransportFlowShim::Unbind( MUpperDataReceiver* /*aReceiver*/, MUpperControl* aControl)

    92     {

    93     (void)aControl;

    94     __ASSERT_DEBUG(aControl == iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 1));

    95     __ASSERT_DEBUG(iDCIdle <= EClientsPresent, User::Panic(KSpecAssert_ESockSSocksspshm, 2));

    96     iDCIdle = EIdle;

    97     iHostResolverNotify = NULL;

    98     if(iSubConnectionProvider.IsOpen())	// legacy flows have no control side

    99     	{

   100     	ProcessDCIdleState();

   101     	}

   102     }

   103 

   104 MLowerDataSender::TSendResult CTransportFlowShim::Send(RMBufChain& /*aData*/)

   105     {

   106     __ASSERT_DEBUG(iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 3));

   107 

   108     TBuf8<sizeof(TConnectionInfo)> buf;

   109     if (Control(KSOLProvider, static_cast<TUint>(KSoConnectionInfo), buf) == KErrNone)

   110         {

   111         iHostResolverNotify->StartSending();

   112         }

   113     else if (!iLowerControl)

   114         {

   115 #ifdef SYMBIAN_NETWORKING_UPS

   116 		TInt result = SetupForNoBearerOnSend();

   117 		if (result != KErrNone)

   118 			{

   119 			return TSendResult(result);

   120 			}

   121 #endif

   122 		__ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockSSocksspshm, 4));	// legacy flows have no control side, so must never get here

   123         PostNoBearer();

   124         }

   125 

   126     return MLowerDataSender::ESendAccepted;

   127     }

   128 //***************************************************************************************

   129 //End of CHostResolver specific functions also look for iHostResolverNotify to find the rest

   130 

   131 #ifndef SYMBIAN_NETWORKING_UPS

   132 

   133 //

   134 // Not used with UPS support - CUpsTransportFlowShim::NewL() used instead.

   135 //

   136 

   137 CTransportFlowShim* CTransportFlowShim::NewL(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)

   138 	{

   139 	return new (ELeave) CTransportFlowShim(aFactory, aSubConn, aProtocolIntf);

   140 	}

   141 

   142 #endif

   143 

   144 CTransportFlowShim::CTransportFlowShim(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)

   145 : CNetworkFlow(aFactory, aSubConn, aProtocolIntf), iFlowParams(TFlowParams(NULL, NULL, KUndefinedProtocol, NULL, NULL))

   146 	{

   147     LOG_NODE_CREATE(KESockFlowTag, CTransportFlowShim)

   148 	}

   149 

   150 

   151 void CTransportFlowShim::SetSSP(CServProviderBase& aSSP)

   152 	{

   153 	__ASSERT_DEBUG(iProvider == NULL, User::Panic(KSpecAssert_ESockSSocksspshm, 5));

   154 	iProvider = &aSSP;

   155 	iProvider->SetNotify(this);

   156 	}

   157 

   158 CTransportFlowShim::~CTransportFlowShim()

   159 	{

   160 	// Remove ourselves from any listening control session's accept queue.

   161 	if(iListenerControlNotify)

   162 		{

   163 		iListenerControlNotify->DisconnectFromListener(*this);

   164 		}

   165 

   166 	if(!iDetaching)

   167 		{

   168 		delete iProvider;

   169 		iProvider = NULL;

   170 		}

   171 

   172 	Messages::TEBase::TError err(TEBase::TNull::Id(), KErrBindersInvalid);

   173     SubConnectionError(err, EErrorAllOperations);

   174 

   175     LOG_NODE_DESTROY(KESockFlowTag, CTransportFlowShim)

   176 	}

   177 

   178 void CTransportFlowShim::SetSockType(TUint aSockType)

   179 	{

   180 	if (iProvider)

   181 		{

   182 		iProvider->SetSockType(aSockType);

   183 		}

   184 	}

   185 

   186 MSessionControl* CTransportFlowShim::GetControlL(TInt aSessionType,MSessionControlNotify& aSessionControlNotify)

   187     {

   188     CNetworkFlow::GetControlL(aSessionType,aSessionControlNotify);

   189     SetSockType(aSessionType);

   190 	return this;

   191     }

   192 

   193 MSessionData* CTransportFlowShim::BindL(MSessionDataNotify& aNotify)

   194     {

   195 	LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tBindL(aNotify 0x%08x)"), this, &aNotify) );

   196 

   197 	// The flow shim now manages custody and loading of the protocol involved.

   198 	// However in the case of host resolvers, until ported for the same behaviour, protocol loading is still managed by the socket.

   199 	if(iFlowParams.iFlowLoadsProtocol)

   200 		{

   201 		CProtocolRef * protocolReference = ProtocolManager::FindProtocolL(

   202 			iFlowParams.iAddrFamily,

   203 			iFlowParams.iSocketType,

   204 			iFlowParams.iProtocol);

   205 

   206         if (protocolReference->GetFlag() & CProtocolRef::EThreePlaneCommsBased)

   207             {

   208             // Three plane comms protos should not be seen here. If an RSocket is opened with a supported

   209             // protocol and it happens to be 3PC this point will be reached. In the case of RTP some

   210             // special processing is performed (in the SCPR) in order to sort out the mess and ensure that

   211             // a UDP/TCP flow is requested instead.

   212             User::Leave(KErrProtocolNotReady);

   213             }

   214 

   215         // Check if the protocol is supported over sockets

   216         if (!(protocolReference->Info().iServiceTypeInfo & ESocketSupport))

   217             {

   218             User::Leave(KErrNotSupported);

   219             }

   220 

   221         // Have the protocol loaded if not already the case and confirm it has socket support

   222         protocolReference->LoadAndBindL();

   223 

   224         __ASSERT_DEBUG(iProtocolReference == NULL, User::Panic(KSpecAssert_ESockSSocksspshm, 6));

   225         iProtocolReference = protocolReference;

   226 

   227         // Have the protocol added to the list of protocols for the session it is associated with

   228         CSockSessionProxy* sessionProxy = reinterpret_cast<CSockSessionProxy*>(iFlowParams.iSessionProxy);

   229         if(sessionProxy != NULL)

   230             {

   231             sessionProxy->AddProtocolL(iProtocolReference->Protocol());

   232             }

   233 

   234         // Fetch a new SAP from the protocol for this flow

   235         if (iProvider == NULL)

   236             {

   237             iProvider = iProtocolReference->Protocol()->NewSAPL(iFlowParams.iSocketType);

   238 

   239 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   240             // Set the options iterating the RArray variable

   241             SetProtocolOptions();

   242 #endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   243     

   244             if (iProvider)

   245                 {

   246                 iProvider->SetNotify(this);

   247                 }

   248             }

   249 		}

   250     

   251     // Now perform the binding proper

   252     if (!iProvider)

   253         {

   254         User::Leave(KErrNotSupported);

   255         }

   256         

   257     __ASSERT_DEBUG(!iHostResolverNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 8));

   258     CNetworkFlow::BindL(aNotify);

   259     iProvider->SetNotify(this);

   260 

   261 	return this;

   262     }

   263 

   264 void CTransportFlowShim::Unbind()

   265     {

   266 	LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tUnbind()"), this) );

   267 

   268 	// Infant mortality case in which binding never completed,

   269 	if(iFlowParams.iProtocol == KUndefinedProtocol)

   270 		{

   271 		delete this;

   272 		return;

   273 		}

   274 

   275 	// Legacy support for host resolvers

   276 	if(iHostResolverNotify)

   277 		{

   278 		__ASSERT_DEBUG(!iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 9));	// can't have both HR & SAP

   279 

   280 		LOG( ESockLog::Printf(_L8("CTransportFlowShim %08x:\tUnbind(): iBearerExpected %d"), this, iBearerExpected) );

   281 		if (!iBearerExpected)

   282 			{

   283 			delete this;

   284 			}

   285 		else

   286 			{

   287 			iDeleteUponBearerReception = ETrue;

   288 			iHostResolverNotify = NULL;

   289 			}

   290 		return;

   291 		}

   292 

   293 	if (iProvider)

   294 		{

   295 		iProvider->SetNotify(NULL);

   296 

   297 		if (!iDetaching)

   298 			{

   299 			delete iProvider;

   300 			iProvider = NULL;

   301 			}

   302 		}

   303 

   304 #ifdef SYMBIAN_NETWORKING_UPS

   305 	// Hook for derived classes to do cleanup before unbind occurs

   306 	PreUnbind();

   307 #endif

   308 

   309 	CNetworkFlow::Unbind();

   310     }

   311 

   312 ESock::CSubConnectionFlowBase& CTransportFlowShim::CloneFlowL()

   313     {

   314     __ASSERT_DEBUG(iProtocolIntf, User::Panic(KSpecAssert_ESockSSocksspshm, 10));

   315     TDefaultFlowFactoryQuery query (iProtocolIntf->ControlProviderId(), iSubConnectionProvider.RecipientId());

   316 	ESock::CSubConnectionFlowBase& flow = static_cast<ESock::CSubConnectionFlowBase&>(*(Factory().CreateObjectL(query)));

   317 	// Legacy flows lack a control provider

   318 	if(iSubConnectionProvider.IsOpen())

   319 		{

   320 		TCFPeer::TJoinRequest msg(flow.Id(), TClientType(TCFClientType::EData, TCFClientType::EActive));

   321 		iSubConnectionProvider.PostMessage(Id(), msg);

   322 		}

   323 	return flow;

   324     }

   325 

   326 void CTransportFlowShim::Start()

   327 	/**

   328 	Start a service provider.

   329 	*/

   330 	{

   331 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 11));

   332 	iProvider->Start();

   333 	}

   334 

   335 void CTransportFlowShim::LocalName(TSockAddr& anAddr) const

   336 /** Gets the local name (address) of the socket service provider entity. The format

   337 of the data in the TSockAddr object is defined by individual protocols.

   338 

   339 The local address is the address of the local machine plus a local port number.

   340 Generally only the port number is important, unless you have two IP interfaces,

   341 for example.

   342 

   343 @param anAddr The address to be filled in */

   344 	{

   345 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 12));

   346 	iProvider->LocalName(anAddr);

   347 	}

   348 

   349 void CTransportFlowShim::SetLocalName(TSockAddr& anAddr)

   350 /** Sets the local name (address) of the socket service provider entity. The format

   351 of the data in the TSockAddr object is defined by individual protocols.

   352 

   353 @param anAddr The address */

   354 	{

   355 	CNetworkFlow::SetLocalName(anAddr);

   356 	PostDataClientRouted();

   357 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 65));

   358 	TInt err = iProvider->SetLocalName(anAddr);

   359 	if (err != KErrNone)

   360 		{

   361 		// Post TError to self, which will result in SubConnectionError to

   362 		// be called in the TError handling. Have to fake that the message is

   363 		// coming from iSubConnectionProvider otherwise ReceivedL will leave.

   364 		RClientInterface::OpenPostMessageClose(iSubConnectionProvider.RecipientId(), Id(), TEBase::TError(err).CRef());

   365 		return;

   366 		}

   367 

   368 	SetLocalNameProcess();

   369 	}

   370 

   371 void CTransportFlowShim::SetLocalNameProcess()

   372 	{

   373 	TBool bearerSent = EFalse;

   374 	if(iFlowParams.iFlowRequestType != TFlowParams::EImplicit)

   375 		{

   376 		// For explicit sockets, TNoBearer will be sent out if it has not already

   377 		// been done so. This was introduced for PREQ2279, as it is necessary

   378 		// to lock this SAP to an interface for incoming sockets. Once locked,

   379 		// this ensures that any incoming packets are only accepted over the locked down

   380 		// interface and no other interfaces. To lock the interface down the

   381 		// NoBearer sequence is executed. This change will also now apply to

   382 		// outgoing explicit sockets. The change for outgoing explicit sockets is

   383 		// that the NoBearer sequence is started here instead of when receiving

   384 		// a NoBearer upcall from the protocol.

   385 

   386 		// Attempt to send out TNoBearer.

   387 		if (DoNoBearer())

   388 		    {

   389 		    // TNoBearer was sent out.

   390 			bearerSent = ETrue;

   391 		    }

   392 		}

   393 

   394 	if (!bearerSent)

   395 		{

   396 		// No Bearer was already sent out earlier, or this is an implicit socket.

   397 		iSessionControlNotify->SetLocalNameComplete();

   398 		}

   399 	}

   400 

   401 

   402 TBool CTransportFlowShim::DoNoBearer()

   403 /**

   404 Do the actual no Bearer call.

   405 @return ETrue if the NoBearer post was actually done, EFalse otherwise

   406 */

   407 	{

   408 	TInt ret = EFalse;

   409 	if(!iIsStopped)

   410 		{ // Prevent sending NoBearer if DataClientStop was received

   411 		if (LockToConnectionInfo() != KErrNone)

   412 		    {

   413 	        __ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockSSocksspshm, 66));

   414 			PostNoBearer();

   415 			ret = ETrue;

   416 		    }

   417 		iUseBearerErrors = EFalse;

   418 		ClearDataClientRoutedGuard();

   419 		}

   420 	return ret;

   421 	}

   422 

   423 

   424 

   425 void CTransportFlowShim::RemName(TSockAddr& anAddr) const

   426 /** Gets the remote name (address) of the socket service provider entity. The format

   427 of the data in the TSockAddr object is defined by individual protocols.

   428 

   429 A remote address is either the address you're sending data to (non connection-oriented

   430 sockets)* or the remote end of the connection. It is the address of the remote

   431 machine (your peer in the network) plus a port number.

   432 

   433 @note RemName is only meaningful if the socket server client has called Connect()

   434 to set up a default address for SendTo(). This function will only be called

   435 on the protocol if this is the case.

   436 

   437 @param anAddr The address to be filled in */

   438 	{

   439 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 14));

   440 	iProvider->RemName(anAddr);

   441 	}

   442 

   443 TInt CTransportFlowShim::SetRemName(TSockAddr& anAddr)

   444 /** Sets the remote name (address) of the socket service provider entity. The format

   445 of the data in the TSockAddr object is defined by individual protocols.

   446 

   447 @param anAddr The address

   448 @return Returns KErrNone if the remote name is correctly set or, if this is

   449 not the case, an informative error number. */

   450 	{

   451 	CNetworkFlow::SetRemName(anAddr);

   452 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 15));

   453 	return iProvider->SetRemName(anAddr);

   454 	}

   455 

   456 TInt CTransportFlowShim::GetOption(TUint aLevel, TUint aName, TDes8& anOption) const

   457 /** Gets some protocol specific option when called by the socket server on behalf of a

   458 client. A protocol may pass the request down a protocol	stack (to protocols it is bound

   459 to) using the GetOption() function of CProtocolBase.

   460 

   461 @param aLevel Option level.

   462 @param aName Option name.

   463 @param anOption Option data.

   464 @return System wide error code.

   465 */

   466 	{

   467 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 16));

   468 	return iProvider->GetOption(aLevel, aName, anOption);

   469 	}

   470 

   471 void CTransportFlowShim::Ioctl(TUint aLevel, TUint aName, TDes8* anOption)

   472 /** Performs some protocol specific IO control.

   473 

   474 @note If this function is called erroneously, the protocol should call Error() on the

   475 socket. If an Ioctl call is already outstanding, the client will be panicked with the

   476 value ETwoIoctls.

   477 

   478 @param aLevel Option level.

   479 @param aName Option name.

   480 @param anOption Option data.

   481 */

   482 	{

   483 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 17));

   484 	iProvider->Ioctl(aLevel, aName, anOption);

   485 	}

   486 

   487 void CTransportFlowShim::CancelIoctl(TUint aLevel, TUint aName)

   488 /** Cancels an outstanding Ioctl call. You are guaranteed only to have one outstanding

   489 at once.

   490 

   491 @param aLevel IOCTL level.

   492 @param aName IOCTL name.

   493 */

   494 	{

   495 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 18));

   496 	iProvider->CancelIoctl(aLevel, aName);

   497 	}

   498 

   499 TInt CTransportFlowShim::SetOption(TUint aLevel, TUint aName, const TDesC8 &anOption)

   500 /** Sets some protocol specific option when called by the socket server on behalf of a

   501 client. A protocol may pass the request down a protocol	stack (to protocols it is bound

   502 to) using the SetOption() function	of CProtocolBase.

   503 

   504 @param aLevel Option level.

   505 @param aName Option name.

   506 @param anOption Option data.

   507 @return System wide error code.

   508 */

   509 	{

   510 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 19));

   511 	return iProvider->SetOption(aLevel, aName, anOption);

   512 	}

   513 

   514 void CTransportFlowShim::ActiveOpen()

   515 /** Initiates a connection operation - this means that it tells the protocol to

   516 attempt to connect to a peer. It is called by the socket server in response

   517 to a connect request from a client.

   518 

   519 This version of the function has user data in the connection frame.

   520 

   521 Only ever called on connection-oriented sockets. Such a socket

   522 should always have both the local address and the remote address specified

   523 before this function is called. If this is not the case then the protocol

   524 should panic.

   525 

   526 When a connection has completed, the protocol should call ConnectComplete()

   527 on its TNotify. If an error occurs during connection the protocol should not

   528 call ConnectComplete() at all; instead it should call Error().

   529 */

   530 	{

   531 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 20));

   532 	iProvider->ActiveOpen();

   533 	}

   534 

   535 void CTransportFlowShim::ActiveOpen(const TDesC8& aConnectionData)

   536 /** Initiates a connection operation - this means that it tells the protocol to

   537 attempt to connect to a peer. It is called by the socket server in response

   538 to a connect request from a client.

   539 

   540 This version of the function has user data in the connection frame.

   541 

   542 Only ever called on connection-oriented sockets. Such a socket

   543 should always have both the local address and the remote address specified

   544 before this function is called. If this is not the case then the protocol

   545 should panic.

   546 

   547 When a connection has completed, the protocol should call ConnectComplete()

   548 on its TNotify. If an error occurs during connection the protocol should not

   549 call ConnectComplete() at all; instead it should call Error().

   550 

   551 @param aConnectionData If the protocol supports user specified connection

   552 data, then it will be held in this buffer. */

   553 	{

   554 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 21));

   555 	iProvider->ActiveOpen(aConnectionData);

   556 	}

   557 

   558 TInt CTransportFlowShim::PassiveOpen(TUint aQueueSize)

   559 /** Tells the protocol to start waiting for an incoming connection request on this

   560 socket (i.e. port). It is called by the socket server in response to a listen

   561 request from a client.

   562 

   563 Only ever called on connection-oriented sockets. Such a socket

   564 should always have both the local address and the remote address specified

   565 before this function is called. If this is not the case, then the protocol

   566 should panic.

   567 

   568 The aQue parameter is the number of sockets which can be waiting for an outstanding

   569 Start after calling ConnectComplete(). The protocol should keep a count of

   570 sockets in this state - incrementing a variable in ConnectComplete(), and

   571 decrementing it in Start().

   572 

   573 When a connection has completed, the protocol should call ConnectComplete()

   574 on its TNotify. If an error occurs during connection the protocol should not

   575 call ConnectComplete() at all; instead it should call Error().

   576 

   577 @param aQueSize Size of connect queue.

   578 */

   579 	{

   580 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 22));

   581 	return iProvider->PassiveOpen(aQueueSize);

   582 	}

   583 

   584 TInt CTransportFlowShim::PassiveOpen(TUint aQueueSize, const TDesC8& aConnectionData)

   585 /** Tells the protocol to start waiting for an incoming connection request on this

   586 socket (i.e. port). It is called by the socket server in response to a listen

   587 request from a client.

   588 

   589 This version of the function has user data in the connection frame.

   590 

   591 Only ever called on connection-oriented sockets. Such a socket

   592 should always have both the local address and the remote address specified

   593 before this function is called. If this is not the case then the protocol

   594 should panic.

   595 

   596 The aQue parameter is the number of sockets which can be waiting for an outstanding

   597 Start after calling ConnectComplete(). The protocol should keep a count of

   598 sockets in this state - incrementing a variable in ConnectComplete(), and

   599 decrementing it in Start().

   600 

   601 When a connection has completed the protocol should call ConnectComplete()

   602 on its TNotify. If an error occurs during connection the protocol should not

   603 call ConnectComplete() at all; instead it should call Error().

   604 

   605 @param aQueueSize size of connect queue

   606 @param aConnectionData if the protocol supports user specified connection data

   607 then it will be held in this buffer. */

   608 	{

   609 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 23));

   610 	return iProvider->PassiveOpen(aQueueSize, aConnectionData);

   611 	}

   612 

   613 void CTransportFlowShim::Shutdown(MSessionControl::TCloseType aOption)

   614 /** Terminates a connection (or closes a non connection-oriented socket down).

   615 

   616 The value of the option argument specifies the type of processing which will

   617 be required of the protocol after this function is called.

   618 

   619 Normally, when the socket server has called Shutdown() for a socket, it will

   620 wait for the socket to call CanClose() before destroying the CServProviderBase

   621 object. However, if the option argument is EImmediate, the CServProviderBase

   622 will be destroyed as soon as Shutdown() returns.

   623 

   624 @param option The shutdown type. */

   625 	{

   626 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 24));

   627 	if (aOption == MSessionControl::EImmediate)

   628 		{

   629 		iShuttingDown = ETrue;

   630 		}

   631 

   632 	// It is possible for the provider to be null if an error occurs immediatly

   633 	// after socket creation before the flow is bound and the provider is received

   634 	// from the protocol.

   635 	if(iProvider)

   636 		{

   637 		iProvider->Shutdown(CServProviderBase::TCloseType(aOption));

   638 		}

   639 	}

   640 

   641 void CTransportFlowShim::Shutdown(MSessionControl::TCloseType aOption, const TDesC8& aDisconnectionData)

   642 /** Terminates a connection (or closes a non connection-oriented socket down).

   643 

   644 The value of the option argument specifies the type of processing which will

   645 be required of the protocol after this function is called.

   646 

   647 Normally, when the socket server has called Shutdown() for a socket, it will

   648 wait for the socket to call CanClose() before destroying the CServProviderBase

   649 object. However, if the option argument is EImmediate, the CServProviderBase

   650 will be destroyed as soon as Shutdown() returns.

   651 

   652 @param option The shutdown type.

   653 @param aDisconnectionData If the protocol supports disconnect data, any such

   654 data required will be held in this buffer. */

   655 	{

   656 	// It is possible for the provider to be null if an error occurs immediatly

   657 	// after socket creation before the flow is bound and the provider is received

   658 	// from the protocol.

   659 	if(iProvider)

   660 		{

   661 		iProvider->Shutdown(CServProviderBase::TCloseType(aOption), aDisconnectionData);

   662 		}

   663 	}

   664 

   665 void CTransportFlowShim::AutoBind()

   666 /** Specifies that the protocol should choose a local address for the service access

   667 point itself. */

   668 	{

   669 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 25));

   670 	iProvider->AutoBind();

   671 	SetLocalNameProcess();

   672 

   673 	}

   674 

   675 TUint CTransportFlowShim::Write(const TDesC8& aDesc, TUint aOptions, TSockAddr* anAddr)

   676 /** Sends data onto the network via the protocol.

   677 

   678 Connection-oriented sockets must be in a connected state (that is ConnectComplete() has

   679 been called on their MSocketNotify before Write() is called).

   680 

   681 The socket server keeps track of how much data is waiting and then tries to send it all

   682 until the protocol tells it to hold off by returning 0 (datagram sockets) or 'less than

   683 all data consumed' (stream sockets) to Write(). The protocol should call CanSend() when it

   684 is ready to send more data.

   685 

   686 anAddr is the address to write the data to.	Connection oriented sockets always use the

   687 default value.

   688 

   689 @param aDesc The data to be sent.

   690 @param aOptions Protocol specific options.

   691 @param anAddr Address to write the data to.

   692 

   693 @returns For stream-oriented protocols the return value is the number of bytes actually written.

   694 If this is less than the length of the descriptor then the protocol should call CanSend()

   695 when it is ready to send more data. For datagram-oriented protocols, the write should return

   696 either 0 if the write cannot be completed, or the length of the descriptor if the write succeeds -

   697 no other values are valid. If the Write() must return 0, then it should call CanSend() when it is

   698 ready to send more data. If the Write() fails due to some error, then it should call Error() with

   699 an informative error number.

   700 */

   701 	{

   702 	CNetworkFlow::Write( aDesc, aOptions, anAddr);

   703 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 26));

   704 	return iProvider->Write(aDesc, aOptions, anAddr);

   705 	}

   706 

   707 TInt CTransportFlowShim::Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr)

   708 /** Sends data onto the network via the protocol.

   709 

   710 Connection-oriented sockets must be in a connected state (that is ConnectComplete() has

   711 been called on their MSocketNotify before Write() is called).

   712 

   713 The socket server keeps track of how much data is waiting and then tries to send it all

   714 until the protocol tells it to hold off by returning 0 (datagram sockets) or 'less than

   715 all data consumed' (stream sockets) to Write(). The protocol should call CanSend() when it

   716 is ready to send more data.

   717 

   718 anAddr is the address to write the data to.	Connection oriented sockets always use the

   719 default value.

   720 

   721 @param aData The data to be sent.

   722 @param aOptions Protocol specific options.

   723 @param anAddr Address to write the data to.

   724 

   725 @returns For stream-oriented protocols the return value is the number of bytes actually written.

   726 If this is less than the length of the descriptor then the protocol should call CanSend()

   727 when it is ready to send more data. For datagram-oriented protocols, the write should return

   728 either 0 if the write cannot be completed, or the length of the descriptor if the write succeeds -

   729 no other values are valid. If the Write() must return 0, then it should call CanSend() when it is

   730 ready to send more data. If the Write() fails due to some error, then it should call Error() with

   731 an informative error number.

   732 */

   733 	{

   734 	CNetworkFlow::Write(aData, aOptions, anAddr);

   735 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 27));

   736 	return iProvider->Write(aData, aOptions, anAddr);

   737 	}

   738 

   739 void CTransportFlowShim::GetData(TDes8& aDesc, TUint aOptions, TSockAddr* anAddr)

   740 /** Gets data which the protocol has indicated is waiting in its buffers using the NewData

   741 up-call on the MSocketNotify.

   742 

   743 GetData() will only ever be called for as much data as the protocol has specified it can process

   744 using the NewData up-call.

   745 

   746 For stream oriented protocols GetData() should fill the descriptor with data from the stream. On

   747 a datagram protocol GetData() should copy one datagram into the descriptor and set the length of

   748 the descriptor. If a full datagram will not fit into the supplied descriptor, the overflow should

   749 be discarded.

   750 

   751 anAddr should be filled in by the protocol with the address of where the data came from.

   752 

   753 @param aDesc  The buffer for data.

   754 @param aOptions Protocol specific options.

   755 @param anAddr Address where the data came from.

   756 */

   757 	{

   758 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 28));

   759 	iProvider->GetData(aDesc, aOptions, anAddr);

   760 	}

   761 

   762 TInt CTransportFlowShim::GetData(RMBufChain& aData, TUint aLength, TUint aOptions, TSockAddr* anAddr)

   763 /** Gets data which the protocol has indicated is waiting in its buffers using the NewData

   764 up-call on the MSocketNotify.

   765 

   766 GetData() will only ever be called for as much data as the protocol has specified it can process

   767 using the NewData up-call.

   768 

   769 For stream oriented protocols GetData() should fill the descriptor with data from the stream. On

   770 a datagram protocol GetData() should copy one datagram into the descriptor and set the length of

   771 the descriptor. If a full datagram will not fit into the supplied descriptor, the overflow should

   772 be discarded.

   773 

   774 anAddr should be filled in by the protocol with the address of where the data came from.

   775 

   776 @param aDesc  The buffer for data.

   777 @param aOptions Protocol specific options.

   778 @param anAddr Address where the data came from.

   779 */

   780 	{

   781 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 29));

   782 	return iProvider->GetData(aData, aLength, aOptions, anAddr);

   783 	}

   784 

   785 TInt CTransportFlowShim::SecurityCheck(MProvdSecurityChecker* aChecker)

   786 /**

   787 Ask the SAP provider to perform a security policy check on the client process (default implementation).

   788 */

   789 	{

   790 	// ********************************************************************

   791 	// NOTE: KErrNone for now, but this should be changed to KErrNotSupported to

   792 	// turn on strict checking and fail PRTs that have not been secured.

   793 	// ********************************************************************

   794 

   795 	__ASSERT_DEBUG(iProvider, User::Panic(KSpecAssert_ESockSSocksspshm, 30));

   796 	return iProvider->SecurityCheck(aChecker);

   797 	}

   798 

   799 void CTransportFlowShim::NewData(TUint aCount)

   800 	{

   801 	__ASSERT_DEBUG(iSessionDataNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 31));

   802 	iSessionDataNotify->NewData(aCount);

   803 	}

   804 

   805 void CTransportFlowShim::CanSend()

   806 	{

   807 	__ASSERT_DEBUG(iSessionDataNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 32));

   808 	iSessionDataNotify->CanSend();

   809 	}

   810 

   811 void CTransportFlowShim::ConnectComplete()

   812 	{

   813 	__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 33));

   814 	iSessionControlNotify->ConnectComplete();

   815 	}

   816 

   817 void CTransportFlowShim::ConnectComplete(const TDesC8& aConnectData)

   818 	{

   819 	__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 34));

   820 	iSessionControlNotify->ConnectComplete(aConnectData);

   821 	}

   822 

   823 CTransportFlowShim* CTransportFlowShim::CloneNSetSAP(CServProviderBase& aSSP)

   824     {

   825 	//Here we can afford to create a flow directly since we know sub-connection

   826 	//+ protocols & flow plug-is've been already loaded while opening listenning socket

   827 	//this is the only case when flow joins without being created from control side

   828 	CTransportFlowShim* shimFlow = NULL;

   829 	TRAPD(ret,shimFlow = factoryobject_cast<CTransportFlowShim>(&CloneFlowL()));

   830 	if (ret != KErrNone)

   831 		{

   832 		Error(ret,MSessionControlNotify::EErrorCompleteConnect);

   833 		}

   834 	else

   835 	    {

   836         __ASSERT_DEBUG(shimFlow, User::Panic(KSpecAssert_ESockSSocksspshm, 35)); //otherwise we shouldn't be here

   837        	shimFlow->SetSSP(aSSP);

   838        	shimFlow->iFlowParams = iFlowParams;

   839 	    }

   840 	return shimFlow;

   841     }

   842 

   843 void CTransportFlowShim::ConnectComplete(CServProviderBase& aSSP)

   844 	{

   845 	CTransportFlowShim* shimFlow;

   846 	if ((shimFlow = CloneNSetSAP(aSSP)) != NULL)

   847 		{

   848 		__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 36));

   849 

   850 		// Store a pointer to the listening control session in case we need to unbind before

   851 		// the passively opened socket is accepted.

   852 		shimFlow->iListenerControlNotify = iSessionControlNotify;

   853 

   854 		iSessionControlNotify->ConnectComplete(*shimFlow);

   855 		}

   856 	}

   857 

   858 void CTransportFlowShim::ConnectComplete(CServProviderBase& aSSP,const TDesC8& aConnectData)

   859 	{

   860 //	CTransportFlowShim* shim = NULL;

   861 //	TRAPD(ret, shim = CTransportFlowShim::NewL(aSSP, NULL, iProtocolId));

   862 

   863 	CTransportFlowShim* shimFlow;

   864     if ((shimFlow = CloneNSetSAP(aSSP)) != NULL)

   865 		{

   866 		__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 37));

   867 		iSessionControlNotify->ConnectComplete(*shimFlow, aConnectData);

   868 		}

   869 	}

   870 

   871 void CTransportFlowShim::CanClose(MSocketNotify::TDelete aDelete)

   872 	{

   873 	LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tCanClose() aDelete %d"), this, aDelete) );

   874 

   875 	if(iSessionControlNotify)

   876 		{

   877 		iDetaching = aDelete == MSocketNotify::EDetach;

   878 		iSessionControlNotify->CanClose(MSessionControlNotify::TDelete(aDelete));

   879         if(aDelete==MSocketNotify::EDetach)

   880             {

   881             iProvider = NULL;

   882             }

   883 		}

   884 	else

   885 		{

   886 		LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tCanClose() no control above us to notify (open was likely passive and has not been accepted yet) so simply unbinding"), this) );

   887 

   888 		// No control above us - likely cause is that we're the result of a passive open that

   889 		// hasn't yet been accepted.

   890 		Unbind();

   891 		}

   892 	}

   893 

   894 void CTransportFlowShim::CanClose(const TDesC8& aDisconnectData,MSocketNotify::TDelete aDelete)

   895 	{

   896 	LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tCanClose() aDisconnectData %08x, aDelete %d"), this, aDisconnectData.Ptr(), aDelete) );

   897 

   898 	if(iSessionControlNotify)

   899 		{

   900         iDetaching = aDelete == MSocketNotify::EDetach;

   901 		iSessionControlNotify->CanClose(aDisconnectData, MSessionControlNotify::TDelete(aDelete));

   902 		if(aDelete==MSocketNotify::EDetach)

   903 			{

   904 			iProvider = NULL;

   905 			}

   906 		}

   907 	else

   908 		{

   909 		LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tCanClose() no control above us to notify (open was likely passive and has not been accepted yet) so simply unbinding"), this) );

   910 

   911 		// No control above us - likely cause is that we're the result of a passive open that

   912 		// hasn't yet been accepted.

   913 		Unbind();

   914 		}

   915 	}

   916 

   917 void CTransportFlowShim::Error(TInt anError, TUint anOperationMask)

   918 	{

   919 	LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tError() anError %d, anOperationMask %d"), this, anError, anOperationMask) );

   920 

   921 	NM_LOG((KESockServerTag, _L8("CTransportFlowShim %08x:\tSynchronous call: From=%08x To=%08x Func=Error(%d)"),

   922 			this, static_cast<Messages::ANode*>(this), static_cast<Messages::ANode*>(this), anError) )

   923 

   924 	if(iSessionControlNotify)

   925 		{

   926 		if (iSessionControlNotify->Error(anError, anOperationMask) != KErrNone)

   927 	    	{

   928 	    	if (iLowerFlow)

   929 	    		{

   930 	    		iLowerFlow->Unbind(NULL,NULL);

   931 	    		iLowerFlow = NULL;

   932 	    		}

   933 	        iLowerControl = NULL;

   934 	    	}

   935 		}

   936 	else

   937 		{

   938 		LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tError() no control above us to notify (open was likely passive and has not been accepted yet) so simply unbinding"), this) );

   939 

   940 		// No control above us - likely cause is that we're the result of a passive open that

   941 		// hasn't yet been accepted.

   942 		iDetaching = MSocketNotify::EDetach;

   943 		Unbind();

   944 		}

   945 	}

   946 

   947 void CTransportFlowShim::Disconnect(void)

   948 	{

   949 	LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tDisconnect()"), this) );

   950 

   951 	if(iSessionControlNotify)

   952 		{

   953 		iSessionControlNotify->Disconnect();

   954 		}

   955 	else

   956 		{

   957 		LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tDisconnect() no control above us to notify (open was likely passive and has not been accepted yet) so simply unbinding"), this) );

   958 

   959 		// No control above us - likely cause is that we're the result of a passive open that

   960 		// hasn't yet been accepted.

   961 		iDetaching = MSocketNotify::EDetach;

   962 		Unbind();

   963 		}

   964 	}

   965 

   966 void CTransportFlowShim::Disconnect(TDesC8& aDisconnectData)

   967 	{

   968 	LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tDisconnect() aDisconnectData %08x"), this, aDisconnectData.Ptr()) );

   969 

   970 	if(iSessionControlNotify)

   971 		{

   972 		iSessionControlNotify->Disconnect(aDisconnectData);

   973 		}

   974 	else

   975 		{

   976 		LOG( ESockLog::Printf(_L("CTransportFlowShim %08x:\tDisconnect() no control above us to notify (open was likely passive and has not been accepted yet) so simply unbinding"), this) );

   977 

   978 		// No control above us - likely cause is that we're the result of a passive open that

   979 		// hasn't yet been accepted.

   980 		iDetaching = MSocketNotify::EDetach;

   981 		Unbind();

   982 		}

   983 	}

   984 

   985 void CTransportFlowShim::IoctlComplete(TDesC8 *aBuf)

   986 	{

   987 	__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockSSocksspshm, 38));

   988 	iSessionControlNotify->IoctlComplete(aBuf);

   989 	}

   990 

   991 void CTransportFlowShim::NoBearer(const TDesC8& aConnectionParams)

   992 /**

   993 Upcall from protocol indicating no underlying bearer for the socket.

   994 @param aConnectionParams Additional connection parameters from the stack, in the form of a

   995 human readable string.  Initially, the required protocols (e.g. "protocol=ip").

   996 */

   997 	{

   998 	// *** NOTE ***

   999 	// overridden by CUpsTransportFlowShim::NoBearer() for UPS support

  1000 

  1001 	(void)aConnectionParams;

  1002 	LOG( ESockLog::ConnectionInfoPrintf(aConnectionParams, _L("CTransportFlowShim %08x:\tNoBearer()"), this) );

  1003 

  1004 	DoNoBearer(); // Do not care if actually posted, so no need to check return value

  1005 

  1006 	}

  1007 

  1008 void CTransportFlowShim::Bearer(const TDesC8& aConnectionInfo)

  1009 	{

  1010 	//we might need to translate the aConnectionInfo into "our" conn info format

  1011 	LOG( ESockLog::ConnectionInfoPrintf(aConnectionInfo, _L("CTransportFlowShim %08x:\tBearer()"), this) );

  1012 

  1013 #if defined(SYMBIAN_TRACE_ENABLE)

  1014 	const TSoIfConnectionInfo *info = REINTERPRET_CAST(const TSoIfConnectionInfo*, aConnectionInfo.Ptr());

  1015 	NM_LOG((KESockServerTag, _L8("CTransportFlowShim %08x:\tSynchronous call: From=%08x To=%08x Func=Bearer(Iap %d, Network %d)"),

  1016 			this, static_cast<Messages::ANode*>(this), static_cast<Messages::ANode*>(this), info->iIAPId, info->iNetworkId) )

  1017 #endif

  1018 

  1019 	if (TConnectionInfo::IsLocalBearer(aConnectionInfo))

  1020 		{

  1021 		return;

  1022 		}

  1023 

  1024 	iUseBearerErrors = ETrue;

  1025 	LocalName(iLocalAddress);

  1026 	iLocalAddressSet = ETrue;

  1027 	RemName(iRemoteAddress);

  1028 	iRemoteAddressSet = ETrue;

  1029 	__ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockSSocksspshm, 41));	// legacy flows have no control side; should never get here

  1030 

  1031 	PostDataClientRouted();

  1032 	}

  1033 

  1034 TInt CTransportFlowShim::LockToConnectionInfo()

  1035 	{

  1036 	//bind provider with the selected connection

  1037 	// Note that the following SetOption() can result in an upcall into

  1038 	// CTransportFlowShim::Bearer() in the same stack frame.

  1039     TPckgBuf<TConnectionInfo> info;

  1040     if (Control(KSOLProvider, static_cast<TUint>(KSoConnectionInfo), info) == KErrNone)

  1041 		{

  1042 		LOG(ESockLog::Printf(_L("CTransportFlowShim %08x:\tLockToConnectionInfo() Iap %d, Network %d"), this, info().iIapId, info().iNetId));

  1043 		NM_LOG((KESockServerTag, _L8("CTransportFlowShim %08x:\tSynchronous call: From=%08x To=%08x Func=LockToConnectionInfo(Iap %d, Network %d)"),

  1044 				this, static_cast<Messages::ANode*>(this), static_cast<Messages::ANode*>(this), info().iIapId, info().iNetId) )

  1045 

  1046 		TPckg<TSoIfConnectionInfo> ifInfo(iIfInfo);

  1047 	    ifInfo().iIAPId = info().iIapId;

  1048     	ifInfo().iNetworkId = info().iNetId;

  1049 		iProvider->SetOption(KSOLProvider, static_cast<TUint>(KSoConnectionInfo), ifInfo);

  1050 		return KErrNone;

  1051 		}

  1052     else

  1053     	{

  1054     	LOG(ESockLog::Printf(_L("CTransportFlowShim %08x:\tLockToConnectionInfo()"), this));

  1055     	return KErrNotFound;

  1056     	}

  1057 	}

  1058 

  1059 void CTransportFlowShim::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

  1060     {

  1061     if (aMessage.IsMessage<TCFDataClient::TBindTo>() && !NoBearerGuard())

  1062     	{

  1063     	//TODO PROD RZ

  1064     	//This needs investigating and fixing. There are two cases for why is this needed here:

  1065     	//(1) Bearer mobility is the only scenario for unsolicited TBindTo

  1066     	//(hence checking the guard above). CTransportFlowShim cannot just migrate to the new, as the

  1067     	//socket above it needs to be rebound. mobility_761220:

  1068     	//  (1) opens and starts a connection

  1069     	//  (2) opens a socket against

  1070     	//  (3) sendreceive UDP data and expects (packet colouring) that data to go via IAP4.

  1071     	//  (4) migrates to another bearer (IAP5)

  1072     	//  (5) uses the same socket (without rebinding) to sendreceive data and expects

  1073     	//    the data to go via IAP4 again (despite migrating).

  1074     	//Talk to Ivan Kelly to find out if this is a requirement on the socket (stays connected

  1075     	//over the old until rebound) or is this a wrong test case.

  1076     	//If the former, ipscpr will need changing not to propagate TBindTo to its flows if they

  1077     	//don't ask.

  1078     	//(2) Rejoing this flow. During rejoin scenario, it's the new owner obtains its new

  1079     	//dataclient ('this') before ('this') dataclient knowing. The rejoin procedure is make

  1080     	//before break, hence it tries to apply the new owner, during which time the new

  1081     	//owner starts and hence attempts to TBindTo his new child. The child hates it

  1082     	//as it arrives from an unknown node. The rejoin protocol needs rethinking.

  1083 		RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete(KErrNone).CRef());

  1084     	return;

  1085     	}

  1086     CNetworkFlow::ReceivedL(aSender, aRecipient, aMessage);

  1087 #ifdef SYMBIAN_NETWORKING_UPS

  1088 	// Allow derived classes to process received messages.

  1089 	//

  1090 	// Rationale for ProcessReceivedL() virtual:

  1091 	// The existing idiom whereby we call CNetworkFlow::ReceivedL() up front is awkward.

  1092 	// If we move that call into the derived class, the derived class can do its

  1093 	// specialised processing and then decide to call this base class method for any

  1094 	// remaining more general processing.  In this case, the ProcessReceivedL() would

  1095 	// not be required.  However, CTransportFlowShim will then become unusable if

  1096 	// instantiated on its own because the call to CNetworkFlow::ReceivedL() is not present.

  1097     TInt ret = ProcessReceivedL(aMessage);

  1098     if (ret == KErrNone || ret != KErrNotSupported)

  1099     	{

  1100     	return;	// PREQ1116 Productisation: RE-WORK ProcessReceivedL().  Perhaps return TBool indicating whether message processed.  Leave if a "real" error.  Extra arguments?

  1101     	}

  1102 #endif

  1103 

  1104    	if ( aMessage.IsMessage<TEBase::TError>() )

  1105    		{

  1106 		SubConnectionError(static_cast<TEBase::TError&>(aMessage));

  1107 		}

  1108    	else if (aMessage.IsMessage<TEBase::TCancel>())

  1109    		{

  1110    		// TCancel can be received as a result of a Connect() being cancelled on the socket and a

  1111    		// TBindToComplete() with an error being sent to the PRBindTo activity on our control provider.

  1112    		}

  1113    	else if (TEChild::ERealmId == aMessage.MessageId().Realm())

  1114 		{

  1115 		switch (aMessage.MessageId().MessageId())

  1116 			{

  1117 		case TEChild::TDestroy::EId :

  1118 			Destroy();

  1119 			break;

  1120 		default:

  1121 			//TODO - logging

  1122 			//LOG(ESockLog::Printf(KESockMetaConnectionTag, _L("ERROR: CTransportFlowShim %08x:\tReceivedL(%s) - KErrNotSupported"), this, aMessage.Printable()));

  1123 			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksspshm, 42)); //For debug configurations

  1124 			User::Leave(KErrNotSupported); //For release configurations

  1125 			}

  1126 		}

  1127 	else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())

  1128 		{

  1129 		switch (aMessage.MessageId().MessageId())

  1130 			{

  1131 		case TCFDataClient::TStart::EId :

  1132 			StartFlowL(aSender);

  1133 			break;

  1134 		case TCFDataClient::TStop::EId :