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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @note PAN agent remote connection state implementations

    19 */

    20 

    21 #include <bluetooth/logger.h>

    22 #include <networking/panuiinterfaces.h>

    23 #include "panagtremdevstates.h"

    24 #include "panagtpolicy.h"

    25 using namespace PanAgent;

    26 

    27 #ifdef __FLOG_ACTIVE

    28 _LIT8(KLogComponent, LOG_COMPONENT_PAN_AGENT);

    29 #endif

    30 

    31 //

    32 // CPanRemDevStatePerformingSdpQuery

    33 //

    34 

    35 CPanRemDevStatePerformingSdpQuery::CPanRemDevStatePerformingSdpQuery(MPanRemDevStateMachineNotify& aStateMachine) :

    36 	CPanRemDevStateBase(aStateMachine, EPanRemDevStatePerformingSdpQuery), iPanDevRolesListPtr(StateMachine().RemoteRolesList())

    37 /**

    38 

    39 */

    40 	{

    41 	}

    42 

    43 void CPanRemDevStatePerformingSdpQuery::OnEntryL()

    44 /**

    45 Check out roles in commdb, perform SDP query if necessary, then check it's OK

    46 @note If SDP queries are inhibited by the setting in commdb, this class will just accept whatever is in there - if there isn't anything then the SDP query will be performed anyway

    47 */

    48 	{

    49 	// perform SDP query to see what the remote device supports

    50 	User::LeaveIfError(StateMachine().RemoteSdpQuerier().Query(StateMachine().RemSockAddr().BTAddr(), iPanDevRolesListPtr, StateMachine().Status()));

    51 	StateMachine().SetActive();

    52 	}

    53 

    54 void CPanRemDevStatePerformingSdpQuery::AsyncEventCompleteL()

    55 /**

    56 The SDP query has completed

    57 */

    58 	{

    59 	//The PAN spec says a device supporting PANU does not have to advertise that on SDP.

    60 	//But the spec is a bit vague on if such a device is connectable, so we try to connect

    61 	//to it anyway to maximise interoperability

    62 	if(StateMachine().Status()==KErrNone || StateMachine().Status()==KErrNotFound)

    63 		{	

    64 		// If remote doesn't support GN, there is no point try it, so set it to Not WorthTrying

    65 		if(!StateMachine().RemoteRolesList().SupportsGn())

    66 			{

    67 			StateMachine().RemoteWorthTryingRolesList().SetWorthTryingGn(EFalse);

    68 			}

    69 		// If remote doesn't support NAP, there is no point try it, so set it to Not WorthTrying

    70 		if(!StateMachine().RemoteRolesList().SupportsNap())

    71 			{

    72 			StateMachine().RemoteWorthTryingRolesList().SetWorthTryingNap(EFalse);

    73 			}

    74 			

    75 		// check whether FixedRemoteRole is supported by remote according to SDP query result

    76 		if(StateMachine().WorthTrying())

    77 			{

    78 			CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStateConnectingSocket(StateMachine());

    79 			LOG1(_L("RemDevState[%x]: <performing SDP query> - SDP query completed successfully, moving to <connecting socket> state"), &StateMachine());

    80 			StateMachine().SetState(*nextState);

    81 			delete this;

    82 			}

    83 		else

    84 			{

    85 			LOG1(_L("RemDevState[%x]: <performing SDP query> - SDP query completed successfully, but remote doesn't support the Fixed Remote Role we've specified."), &StateMachine());

    86 			User::Leave(KErrFixRemoteRoleIsNotSupportedByRemote);

    87 			}

    88 		}

    89 	else // error handling

    90 		{

    91 		LOG1(_L("RemDevState[%x]: <performing SDP query> - SDP query failed"), &StateMachine());

    92 		User::Leave(StateMachine().Status().Int());

    93 		}

    94 	}

    95 

    96 void CPanRemDevStatePerformingSdpQuery::AsyncEventCancelL()

    97 /**

    98 The SDP query has been cancelled

    99 */

   100 	{

   101 	LOG1(_L("RemDevState[%x]: <performing SDP query> - SDP query cancelled"), &StateMachine());

   102 

   103 	StateMachine().RemoteSdpQuerier().CancelQuery();

   104 	}

   105 	

   106 void CPanRemDevStatePerformingSdpQuery::ShutdownL()

   107 /**

   108 The local device wants us to disconnect

   109 */

   110 	{

   111 	LOG1(_L("RemDevState[%x]: <performing SDP query> - locally requested disconnect received"), &StateMachine());

   112 	

   113 	// outstanding async request will be cancelled by state machine when we leave

   114 	User::Leave(KErrLocallyInitiatedDisconnect);

   115 	}

   116 

   117 // This returns a distilled (i.e., not the actual remote device state)

   118 // version of the current connection status of the remote device

   119 TRemoteDeviceState CPanRemDevStatePerformingSdpQuery::GetState() const

   120 	{

   121 	return EIdle;

   122 	}

   123 

   124 //

   125 // CPanRemDevStateConnectingSocket

   126 //

   127 

   128 CPanRemDevStateConnectingSocket::CPanRemDevStateConnectingSocket(MPanRemDevStateMachineNotify& aStateMachine) :

   129 	CPanRemDevStateBase(aStateMachine, EPanRemDevStateConnectingSocket)

   130 /**

   131 

   132 */

   133 	{	}

   134 		

   135 void CPanRemDevStateConnectingSocket::OnEntryL()

   136 /**

   137 

   138 */

   139 	{

   140 	LOG1(_L("RemDevState[%x]: <connecting socket> - entering state"), &StateMachine());

   141 

   142 	TBTServiceSecurity securitySettings;

   143 	// we override whatever security settings that came with the address with our own

   144 	securitySettings.SetAuthentication(KPanOutgoignAuthenticationRequired);

   145 	securitySettings.SetAuthorisation(KPanOutgoingAuthorisationRequired);

   146 	securitySettings.SetEncryption(KPanOutgoingEncryptionRequired);

   147 	securitySettings.SetUid(KBTPanAuthorisationUid);

   148 

   149 	StateMachine().RemSockAddr().SetSecurity(securitySettings);

   150 

   151 #if defined(_DEBUG) && defined(SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY)

   152     TInt err = StateMachine().Socket().Open(KBTAddrFamily, KSockSeqPacket, KL2CAP);

   153     __ASSERT_DEBUG(err != KErrBadName, PanicInState(EPanAgtMissingBinding));

   154     User::LeaveIfError(err);

   155 #else

   156 	User::LeaveIfError(StateMachine().Socket().Open(KBTAddrFamily, KSockSeqPacket, KL2CAP));

   157 #endif

   158 

   159 	TUint16 bnepMtu = KBnepMtu;

   160 	TPckg<TUint16> mtuBuf(bnepMtu);

   161 

   162 	User::LeaveIfError(StateMachine().Socket().SetOpt(KL2CAPInboundMTU, KSolBtL2CAP, mtuBuf));

   163 	User::LeaveIfError(StateMachine().Socket().SetOpt(KL2CAPNegotiatedOutboundMTU, KSolBtL2CAP, mtuBuf));

   164 	// Register the CoD service - Networking bit (especially relevant for WinXP)

   165 	User::LeaveIfError(StateMachine().Socket().SetOpt(KBTRegisterCodService, KSolBtSAPBase, EMajorServiceNetworking));

   166 

   167 	StateMachine().Socket().Connect(StateMachine().RemSockAddr(), StateMachine().Status());

   168 	StateMachine().SetActive();

   169 	}

   170 	

   171 void CPanRemDevStateConnectingSocket::AsyncEventCompleteL()

   172 /**

   173 Called when the new socket is connected

   174 */

   175 	{

   176 	if(StateMachine().Status()==KErrNone)

   177 		{

   178 		LOG1(_L("RemDevState[%x]: <connecting socket> - async event complete, socket connected successfully"), &StateMachine());

   179 

   180 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

   181         StateMachine().CreateNewBnepConnection(StateMachine().Socket(), TPanMessage::EActivityCreateChannelControllerForOutgoing);

   182 #else

   183 		StateMachine().CreateNewBnepConnectionL(StateMachine().Socket());

   184 #endif

   185 

   186 		StateMachine().OpenPhysicalLinkAdapterL();

   187 

   188 		CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection(StateMachine());

   189 

   190 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

   191         CleanupStack::PushL(nextState);

   192         CPanRemDevStatePaused* pausedState = new(ELeave)CPanRemDevStatePaused(StateMachine(), *nextState);

   193         CleanupStack::Pop();

   194         nextState = pausedState;

   195 #endif

   196 

   197 		StateMachine().SetState(*nextState);

   198 		delete this;

   199 		}

   200 	else	// did not complete the connection to the remote device...

   201 		{

   202 		LOG2(_L("RemDevState[%x]: <connecting socket> - socket connect failed with %d"), &StateMachine(), StateMachine().Status().Int());

   203 		User::Leave(StateMachine().Status().Int());

   204 		}

   205 	}	

   206 	

   207 void CPanRemDevStateConnectingSocket::AsyncEventCancelL()

   208 /**

   209 Cancel the socket connect

   210 */

   211 	{

   212 	LOG1(_L("RemDevState[%x]: <connecting socket> - async event cancelled"), &StateMachine());

   213 	

   214 	StateMachine().Socket().CancelConnect();

   215 	StateMachine().Socket().Close();

   216 	}

   217 

   218 void CPanRemDevStateConnectingSocket::ShutdownL()

   219 /**

   220 The local device wants us to disconnect

   221 */

   222 	{

   223 	LOG1(_L("RemDevState[%x]: <connecting socket> - locally requested disconnect received"), &StateMachine());

   224 	

   225 	// outstanding async request will be cancelled by state machine when we leave

   226 	User::Leave(KErrLocallyInitiatedDisconnect);

   227 	}

   228 

   229 // This returns a distilled (i.e., not the actual remote device state)

   230 // version of the current connection status of the remote device

   231 TRemoteDeviceState CPanRemDevStateConnectingSocket::GetState() const

   232 	{

   233 	return EIdle;

   234 	}

   235 

   236 //

   237 // CPanRemDevStateReconnectingSocket

   238 //

   239 

   240 CPanRemDevStateReconnectingSocket::CPanRemDevStateReconnectingSocket(MPanRemDevStateMachineNotify& aStateMachine) :

   241 	CPanRemDevStateBase(aStateMachine, EPanRemDevStateConnectingSocket)

   242 	{	}

   243 		

   244 /**

   245 	Disconnect the socket for the case where the remote device doesn't

   246 */

   247 void CPanRemDevStateReconnectingSocket::OnEntryL()

   248 	{

   249 	LOG1(_L("RemDevState[%x]: <reconnecting socket> - entering state"), &StateMachine());

   250 	StateMachine().Socket().Close();

   251 

   252 	StateMachine().SetRetryConnect();	

   253 	}

   254 

   255 /**

   256 	Wait for device to disconnect before attempting reconnect

   257 */

   258 void CPanRemDevStateReconnectingSocket::RemoteDeviceDisconnectL(TInt /*aErr*/)

   259 	{

   260 	LOG1(_L("RemDevState[%x]: <reconnecting socket> - remote device disconnected"), &StateMachine());

   261 	StateMachine().DisconnectBnepChannel();

   262 	TBTServiceSecurity securitySettings;

   263 	// we override whatever security settings that came with the address with our own

   264 	securitySettings.SetAuthentication(KPanOutgoignAuthenticationRequired);

   265 	securitySettings.SetAuthorisation(KPanOutgoingAuthorisationRequired);

   266 	securitySettings.SetEncryption(KPanOutgoingEncryptionRequired);

   267 	securitySettings.SetUid(KBTPanAuthorisationUid);

   268 

   269 	StateMachine().RemSockAddr().SetSecurity(securitySettings);

   270 

   271 #if defined(_DEBUG) && defined(SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY)

   272     TInt err = StateMachine().Socket().Open(KBTAddrFamily, KSockSeqPacket, KL2CAP);

   273     __ASSERT_DEBUG(err != KErrBadName, PanicInState(EPanAgtMissingBinding));

   274     User::LeaveIfError(err);

   275 #else

   276 	User::LeaveIfError(StateMachine().Socket().Open(KBTAddrFamily, KSockSeqPacket, KL2CAP));

   277 #endif

   278 

   279 	TUint16 bnepMtu = KBnepMtu;

   280 	TPckg<TUint16> mtuBuf(bnepMtu);

   281 

   282 	User::LeaveIfError(StateMachine().Socket().SetOpt(KL2CAPInboundMTU, KSolBtL2CAP, mtuBuf));

   283 	User::LeaveIfError(StateMachine().Socket().SetOpt(KL2CAPNegotiatedOutboundMTU, KSolBtL2CAP, mtuBuf));

   284 

   285 	StateMachine().Socket().Connect(StateMachine().RemSockAddr(), StateMachine().Status());

   286 	StateMachine().SetActive();

   287 	}

   288 

   289 /**

   290 Called when the new socket is connected

   291 */

   292 void CPanRemDevStateReconnectingSocket::AsyncEventCompleteL()

   293 	{

   294 	if(StateMachine().Status()==KErrNone)

   295 		{

   296 		LOG1(_L("RemDevState[%x]: <connecting socket> - async event complete, socket connected successfully"), &StateMachine());

   297 

   298 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

   299         StateMachine().CreateNewBnepConnection(StateMachine().Socket(), TPanMessage::EActivityCreateChannelControllerForOutgoing);

   300 #else

   301 		StateMachine().CreateNewBnepConnectionL(StateMachine().Socket());

   302 #endif

   303 

   304 		StateMachine().OpenPhysicalLinkAdapterL();

   305 

   306 		CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection(StateMachine());

   307 

   308 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

   309         CleanupStack::PushL(nextState);

   310         CPanRemDevStatePaused* pausedState = new(ELeave)CPanRemDevStatePaused(StateMachine(), *nextState);

   311         CleanupStack::Pop();

   312         nextState = pausedState;

   313 #endif

   314 

   315 		StateMachine().SetState(*nextState);

   316 		delete this;

   317 		}

   318 	else	// did not complete the connection to the remote device...

   319 		{

   320 		LOG2(_L("RemDevState[%x]: <connecting socket> - socket connect failed with %d"), &StateMachine(), StateMachine().Status().Int());

   321 		User::Leave(StateMachine().Status().Int());

   322 		}

   323 	}	

   324 

   325 /**

   326 Cancel the socket connect

   327 */

   328 void CPanRemDevStateReconnectingSocket::AsyncEventCancelL()

   329 	{

   330 	LOG1(_L("RemDevState[%x]: <connecting socket> - async event cancelled"), &StateMachine());

   331 	

   332 	StateMachine().Socket().CancelConnect();

   333 	StateMachine().Socket().Close();

   334 	}

   335 

   336 /**

   337 The local device wants us to disconnect

   338 */

   339 void CPanRemDevStateReconnectingSocket::ShutdownL()

   340 	{

   341 	LOG1(_L("RemDevState[%x]: <connecting socket> - locally requested disconnect received"), &StateMachine());

   342 	

   343 	// outstanding async request will be cancelled by state machine when we leave

   344 	User::Leave(KErrLocallyInitiatedDisconnect);

   345 	}

   346 

   347 // This returns a distilled (i.e., not the actual remote device state)

   348 // version of the current connection status of the remote device

   349 TRemoteDeviceState CPanRemDevStateReconnectingSocket::GetState() const

   350 	{

   351 	return EIdle;

   352 	}

   353 

   354 //

   355 // CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection

   356 //

   357 

   358 CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

   359 	CPanRemDevStateBase(aStateMachine, EPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection)

   360 /**

   361 

   362 */

   363 	{	}

   364 	

   365 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::OnEntryL()

   366 /**

   367 Not much to do here - just waiting for role state machine to become available

   368 */

   369 	{	

   370 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - entering state"), &StateMachine());

   371 

   372 	// do nothing

   373 	}

   374 	

   375 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::BnepRoleRequestFromRemoteDeviceL(const TUUID& /*aRequestedLocalRole*/, const TUUID& /*aRequestedRemoteRole*/)

   376 /**

   377 Oi! We're starting the connection here, so we get to send the role request!

   378 */

   379 	{

   380 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - BNEP role request received from remote device - they shouldn't be sending them, we're doing the outgoing connection, disconnecting them"), &StateMachine());

   381 

   382 	// drop the role request packet that the remote device has incorrectly sent us

   383 	}

   384 	

   385 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::BnepRoleResponseFromRemoteDeviceL(TBnepSetupConnectionResponseMessage /*aRoleResponseCode*/)

   386 /**

   387 Excuse me?  We haven't sent a role request yet, so why are they sending a role response?

   388 */

   389 	{

   390 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - BNEP role response received from remote device before we've sent a request - disconnecting them"), &StateMachine());

   391 

   392 	// drop the role response packet that the remote device has incorrectly sent us

   393 	}

   394 

   395 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::RemoteDeviceDisconnectL(TInt aError)

   396 /**

   397 Remote device has obviously given up waiting for us...

   398 */

   399 	{

   400 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - remote device disconnect received, looks like they've given up waiting for us."), &StateMachine());

   401 

   402 	User::Leave(aError); // will shutdown the connection

   403 	}

   404 

   405 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::ReadyForRoleRequestL()

   406 /**

   407 Ahh, that's the event we've really been waiting for - role state machine has finished dealing with

   408 another device and is now ready for our role request

   409 */

   410 	{

   411 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - ready for role request received from role state machine"), &StateMachine());

   412 

   413 	TInt err;

   414 	CPanRemDevStateBase* nextState = NULL;

   415 	StateMachine().RemoteRole() = EPanRoleUnknown;	// reset this for outgoing connection - we maybe trying a different role now

   416 	err = StateMachine().InitiateOutgoingConnection(StateMachine().LocalRole(), StateMachine().RemoteRole(), StateMachine().RemoteWorthTryingRolesList());

   417 		

   418 	switch(err)

   419 		{

   420 		case KErrNone:

   421 			{

   422 			err = PerformMasterSlaveSwitchIfNecessary(StateMachine().LocalRole());

   423 			if(err==KErrWaitingForBasebandRoleSwitch)

   424 				{

   425 				nextState = new(ELeave) CPanRemDevStateWaitingForRoleSwitchForOutgoingConnection(StateMachine());

   426 				break;

   427 				}

   428 			else if(err)

   429 				{

   430 				LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - ...M/S switch required and failed - disconnecting device."), &StateMachine());

   431 				// remote device would not perform role switch (maybe it needs to stay as master for another profile it's using...)

   432 				User::Leave(KErrCouldNotBecomePiconetMaster);

   433 				return;		

   434 				}

   435 				

   436 			LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - ...M/S switch not required, sending role request."), &StateMachine());

   437 

   438 			nextState = new(ELeave) CPanRemDevStatePerformingDelayedRoleNegotiationForOutgoingConnection(StateMachine());

   439 			break;

   440 			}

   441 		case KErrLocked:

   442 			{

   443 			PanicInState(ERoleStateMachineCalledReadyForRoleRequestThenReturnedLocked);

   444 			break;

   445 			}

   446 		case KErrInvalidOrUnacceptableRoleCombination:

   447 			{

   448 			LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - the roles the remote device proposed were invalid or unacceptable to us, disconnecting them"), &StateMachine());

   449 			User::Leave(KErrInvalidOrUnacceptableRoleCombination);

   450 			}

   451 		default:

   452 			{

   453 			// if err is something other than KErrNoMemory that might indicate an internal error in the state

   454 			// machine, so ASSERT_DEBUG.  We can probably carry on even if the error is unexpected, as leaving

   455 			// will cause this connection to shutdown.

   456 			__ASSERT_DEBUG(err == KErrNoMemory, PanicInState(EPanAgentRoleStateMachineReturnedUnexpectedErrorCode));

   457 			User::Leave(err);

   458 			}

   459 		}

   460 		

   461 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

   462 	StateMachine().SetState(*nextState);

   463 	delete this;

   464 	return;

   465 	}

   466 

   467 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::ShutdownL()

   468 /**

   469 Local device wants us to disconnect

   470 */

   471 	{

   472 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for outgoing connection> - locally requested disconnect received"), &StateMachine());

   473 

   474 	User::Leave(KErrLocallyInitiatedDisconnect); // disconnect the remote device

   475 	}

   476 

   477 // This returns a distilled (i.e., not the actual remote device state)

   478 // version of the current connection status of the remote device

   479 TRemoteDeviceState CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::GetState() const

   480 	{

   481 	return EPendingNegotiation;

   482 	}

   483 	

   484 //

   485 // CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection

   486 //

   487 

   488 CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

   489 	CPanRemDevStateBase(aStateMachine, EPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection)

   490 /**

   491 

   492 */

   493 	{	}

   494 

   495 CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection(MPanRemDevStateMachineNotify& aStateMachine, TPanRemDevStates aStateNumber) :

   496 	CPanRemDevStateBase(aStateMachine, aStateNumber)

   497 /**

   498 When implementing a new state that derives from this base class, ensure that

   499 it provides a unique number to identify the state from other possible

   500 states.  @see PanAgent::TPanAgtStates.

   501 */

   502 	{	}

   503 	

   504 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::OnEntryL()

   505 /**

   506 Not much to do here - just waiting for role state machine to become available

   507 */

   508 	{	

   509 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - entering state"), &StateMachine());

   510 

   511 	// do nothing

   512 	}

   513 	

   514 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::BnepRoleRequestFromRemoteDeviceL(const TUUID& /*aRequestedLocalRole*/, const TUUID& /*aRequestedRemoteRole*/)

   515 /**

   516 

   517 */

   518 	{

   519 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - BNEP role request received from remote device, still can't do anything with it until we get access to the role state machine"), &StateMachine());

   520 

   521 	// drop resent role request

   522 	}

   523 	

   524 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::BnepRoleResponseFromRemoteDeviceL(TBnepSetupConnectionResponseMessage /*aRoleResponseCode*/)

   525 /**

   526 @note Shouldn't be called for incoming connections, as they should be sending requests, not responses

   527 */

   528 	{

   529 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - BNEP role response received from remote device, what are they up to?  They should be sending requests and we should be sending responses, disconnecting them"), &StateMachine());

   530 

   531 	// drop the role response packet that the remote device has incorrectly sent us

   532 	}

   533 

   534 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::RemoteDeviceDisconnectL(TInt aError)

   535 /**

   536 Remote device has obviously given up waiting for us...

   537 */

   538 	{

   539 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - remote device disconnect received, looks like they've given up waiting for us."), &StateMachine());

   540 

   541 	User::Leave(aError); // will shutdown the connection

   542 	}

   543 

   544 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::ReadyForRoleRequestL()

   545 /**

   546 Ahh, that's the event we've really been waiting for - role state machine has finished dealing with

   547 another device and is now ready for our role request

   548 */

   549 	{

   550 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - ready for role request received from role state machine"), &StateMachine());

   551 

   552 	TInt err;

   553 	CPanRemDevStateBase* nextState = NULL;

   554 	err = StateMachine().IncomingConnectionFromPeer(StateMachine().LocalRole(), StateMachine().RemoteRole());

   555 

   556 	switch(err)

   557 		{

   558 		case KErrNone:

   559 			{

   560 			err = PerformMasterSlaveSwitchIfNecessary(StateMachine().LocalRole());

   561 			if(err==KErrWaitingForBasebandRoleSwitch)

   562 				{

   563 				nextState = new(ELeave) CPanRemDevStateWaitingForRoleSwitchForIncomingConnection(StateMachine());

   564 				break;

   565 				}

   566 			else if(err)

   567 				{

   568 				LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - ...M/S switch required and failed - disconnecting device."), &StateMachine());

   569 				// remote device would not perform role switch (maybe it needs to stay as master for another profile it's using...)

   570 				StateMachine().SendRoleResponse(EConnectionNotAllowed);

   571 				User::Leave(KErrCouldNotBecomePiconetMaster);

   572 				return;		

   573 				}

   574 				

   575 			LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - ...M/S switch not required, sending successful connect response."), &StateMachine());

   576 			StateMachine().SendRoleResponse(EOperationSuccessful);

   577 

   578  			nextState = new(ELeave) CPanRemDevStateIncomingNotification(StateMachine());

   579 			break;

   580 			}

   581 		case KErrLocked:

   582 			{

   583 			PanicInState(ERoleStateMachineCalledReadyForRoleRequestThenReturnedLocked);

   584 			break;

   585 			}

   586 

   587 		default:

   588 			{

   589 			// An error has occured.  Send a -ve role response and disconnect.

   590 			LOG2(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - Fail with error [%d].  Disconnecting peer"), &StateMachine(), err);

   591 			StateMachine().SendRoleResponse(EConnectionNotAllowed);

   592 			User::Leave(err);

   593 			}

   594 		}

   595 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

   596 	StateMachine().SetState(*nextState);

   597 	delete this;

   598 	return;

   599 	}

   600 

   601 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::ShutdownL()

   602 /**

   603 Local device wants us to disconnect

   604 */

   605 	{

   606 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming connection> - locally requested disconnect received"), &StateMachine());

   607 

   608 	// tell the other end that we're disconnecting

   609 	StateMachine().SendRoleResponse(EConnectionNotAllowed);

   610 	// and then disconnect the remote device

   611 	User::Leave(KErrLocallyInitiatedDisconnect); 

   612 	}

   613 

   614 // This returns a distilled (i.e., not the actual remote device state)

   615 // version of the current connection status of the remote device

   616 TRemoteDeviceState CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::GetState() const

   617 	{

   618 	return EPendingNegotiation;

   619 	}

   620 

   621 //

   622 // CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest

   623 //

   624 

   625 CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest(MPanRemDevStateMachineNotify& aStateMachine, TBluetoothPanRole aPendingLocalRole, TBluetoothPanRole aPendingRemoteRole)

   626   : CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection(aStateMachine, EPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest),

   627 	iPendingLocalRole(aPendingLocalRole),

   628 	iPendingRemoteRole(aPendingRemoteRole)

   629 /**

   630 

   631 */

   632 	{	}

   633 	

   634 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest::OnEntryL()

   635 /**

   636 Not much to do here - just waiting for role state machine to become available

   637 */

   638 	{	

   639 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming role change request> - entering state"), &StateMachine());

   640 

   641 	// do nothing

   642 	}

   643 	

   644 void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingRoleChangeRequest::ReadyForRoleRequestL()

   645 /**

   646 Ahh, that's the event we've really been waiting for - role state machine has finished dealing with

   647 another device and is now ready for our role request

   648 */

   649 	{

   650 	LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming role change request> - ready for role request received from role state machine"), &StateMachine());

   651 

   652 	TInt err;

   653 	CPanRemDevStateBase* nextState = NULL;

   654 	err = StateMachine().RoleChangeRequestFromPeer(iPendingLocalRole, iPendingRemoteRole);

   655 	switch(err)

   656 		{

   657 		case KErrNone:

   658 			{

   659 			err = PerformMasterSlaveSwitchIfNecessary(iPendingLocalRole);

   660 			if(err==KErrWaitingForBasebandRoleSwitch)

   661 				{

   662 				nextState = new(ELeave) CPanRemDevStateWaitingForRoleSwitchForIncomingRoleChangeRequest(StateMachine(), iPendingLocalRole, iPendingRemoteRole);

   663 				break;

   664 				}

   665 			else if(err)

   666 				{

   667 				LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming role change request> - ...M/S switch required and failed - disconnecting device."), &StateMachine());

   668 				// remote device would not perform role switch (maybe it needs to stay as master for another profile it's using...)

   669 				StateMachine().SendRoleResponse(EConnectionNotAllowed);

   670 				StateMachine().RoleChangeFailed();

   671 				nextState = new(ELeave) CPanRemDevStateActive(StateMachine());

   672 				break;

   673 				}

   674 				

   675 			LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming role change request> - ...M/S switch not required, sending successful connect response."), &StateMachine());

   676 			StateMachine().SendRoleResponse(EOperationSuccessful);

   677 

   678 			// Store the new roles

   679 			StateMachine().LocalRole() = iPendingLocalRole;

   680 			StateMachine().RemoteRole() = iPendingRemoteRole;

   681 

   682 			// Changing role from GN/NAP to U.  If this connection previously had access to the

   683 			// uplink this should be revoked.

   684 			if(StateMachine().LocalRole() == EPanRoleU)

   685 				{

   686 				StateMachine().SetUplinkAccessAllowed(EFalse);

   687 				}

   688 

   689 			nextState = new(ELeave) CPanRemDevStateActive(StateMachine());

   690 			break;

   691 			}

   692 		case KErrLocked:

   693 			{

   694 			PanicInState(ERoleStateMachineCalledReadyForRoleRequestThenReturnedLocked);

   695 			break;

   696 			}

   697 		case KErrInvalidOrUnacceptableRoleCombination:

   698 			{

   699 			LOG1(_L("RemDevState[%x]: <waiting for role state machine for incoming role change request> - the roles the remote device proposed were invalid or unacceptable to us, signalling failure and going to active state"), &StateMachine());

   700 			StateMachine().SendRoleResponse(EConnectionNotAllowed);

   701 			nextState = new(ELeave) CPanRemDevStateActive(StateMachine());

   702 			break;

   703 			}

   704 		default:

   705 			{

   706 			// if err is something other than KErrNoMemory that might indicate an internal error in the state

   707 			// machine, so ASSERT_DEBUG.  We can probably carry on even if the error is unexpected, as leaving

   708 			// will cause this connection to shutdown.

   709 			__ASSERT_DEBUG(err == KErrNoMemory, PanicInState(EPanAgentRoleStateMachineReturnedUnexpectedErrorCode));

   710 			User::Leave(err);

   711 			}

   712 		}

   713 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

   714 	StateMachine().SetState(*nextState);

   715 	delete this;

   716 	return;	

   717 	}

   718 

   719 //

   720 // CPanRemDevStatePerformingRoleNegotiationForOutgoingBase

   721 //

   722 

   723 CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::CPanRemDevStatePerformingRoleNegotiationForOutgoingBase(MPanRemDevStateMachineNotify& aStateMachine, TPanRemDevStates aStateNumber) :

   724 	CPanRemDevStateBase(aStateMachine, aStateNumber), iRetries(KMaxBnepNegotiationCyles)

   725 /**

   726 

   727 */

   728 	{	}

   729 

   730 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::BnepRoleRequestFromRemoteDeviceL(const TUUID& /*aRequestedLocalRole*/, const TUUID& /*aRequestedRemoteRole*/)

   731 /**

   732 Something's gone wrong - we were expecting a response from the remote device - not a request. 

   733 Not sure this can/should occur - I think the spec implies that only the initiating device can send role requests.

   734 */

   735 	{

   736 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - BNEP role request from remote device received - what are they doing?  We're supposed to be sending the role requests."), &StateMachine());

   737 

   738 	// drop the role request packet that the remote device has incorrectly sent us

   739 	}

   740 	

   741 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::BnepRoleResponseFromRemoteDeviceL(TBnepSetupConnectionResponseMessage aRoleResponseCode)

   742 /**

   743 Woohoo! Our role response has arrived.

   744 */

   745 	{

   746 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - BNEP role response from remote device received, processing response..."), &StateMachine());

   747 

   748 	StateMachine().Cancel();

   749 	

   750 	CPanRemDevStateBase* nextState = NULL;

   751 	switch(aRoleResponseCode)

   752 		{

   753 		case EOperationSuccessful:

   754 			{

   755 			LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation successful, setting device active."), &StateMachine());

   756 			StateMachine().ResetConnectionRetryAttempts(); // reset the connection retry attempts

   757 			StateMachine().ResetRetryParameters(); // clears the triedpanu... type flags incase we want to reconnect later

   758 			nextState = DoRoleNegotiationSuccessL();

   759 			break;

   760 			}

   761 		case EConnectionNotAllowed:

   762 			{	

   763 			LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, connection not allowed"), &StateMachine());

   764 			TInt retries = StateMachine().IncrementConnectionRetryAttempts();

   765 			// There is a race condition in some PC stacks that can bring us to this point when it shouldn't, so we retry the connection

   766 			if (retries<KPanAgtConnectionRetryAttempts) 

   767 				{

   768 				LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, connection not allowed - retrying connection"), &StateMachine());

   769 				StateMachine().ResetRetryParameters(); // This feeds all the way back so we recalculate the role parameters just the same as we did last time

   770 				nextState = new(ELeave) CPanRemDevStateReconnectingSocket(StateMachine());

   771 			

   772 				// if the state has left, then it won't have performed the setup of the next state correctly

   773 				// this code performs the same actions to cleanup the old state and activate the new, but in

   774 				// reverse order - otherwise we'd lose the pointer to the old state when we activated the new

   775 				}

   776 			/* the intention is to allow the retrys required by the PC stacks above

   777 			   then if it's worth retrying (we can try new roles) we will

   778 			   This is particularly useful when we don't have sdp records to suggest

   779 			   what we should do

   780 			 */				

   781 			else if (StateMachine().WorthTrying())

   782 				{

   783 				// if we've still not made a successful connection then we can have a quick try

   784 				// at connecting using different remote roles

   785 				LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, connection not allowed - retrying connection with different roles"), &StateMachine());

   786 				nextState = new(ELeave) CPanRemDevStateReconnectingSocket(StateMachine());

   787 			

   788 				// if the state has left, then it won't have performed the setup of the next state correctly

   789 				// this code performs the same actions to cleanup the old state and activate the new, but in

   790 				// reverse order - otherwise we'd lose the pointer to the old state when we activated the new

   791 				}

   792 			else 

   793 				{

   794 				LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, connection not allowed"), &StateMachine());

   795 				LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, unrecognised response code, shutting down"), &StateMachine());

   796 				StateMachine().ResetConnectionRetryAttempts(); // reset the connection retry attempts

   797 				StateMachine().ResetRetryParameters(); // clears the triedpanu... type flags incase we want to try connect later

   798 				nextState = DoRoleNegotiationFailureL(KErrCouldNotConnect);

   799 				}

   800 			break;

   801 			}

   802 		default:

   803 			{			

   804 			// this nested switch avoids the old multiple logging lines which was really nasty

   805 			switch(aRoleResponseCode)

   806 				{

   807 				case EInvalidDestinationServiceUuid:	// we've tried to negotiate roles that are unsuitable

   808 					{

   809 					LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, invalid destination service UUID"), &StateMachine());

   810 					break;

   811 					}

   812 				case EInvalidSourceServiceUuid:

   813 					{

   814 					LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, invalid source service UUID"), &StateMachine());

   815 					break;

   816 					}

   817 				case EInvalidServiceUuidSize:

   818 					{

   819 					LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, invalid UUID size"), &StateMachine());

   820 					break;

   821 					}

   822 				default:

   823 					{

   824 					LOG2(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...operation failed, unrecognised response code (%x),  shutting down"), &StateMachine(),aRoleResponseCode);

   825 					break;

   826 					}

   827 				}

   828 			StateMachine().ResetConnectionRetryAttempts(); // reset the connection retry attempts

   829 			StateMachine().ResetRetryParameters(); // clears the triedpanu... type flags incase we want to try connect later

   830 			nextState = DoRoleNegotiationFailureL(KErrCouldNotConnect);

   831 			break;	

   832 			}

   833 		}

   834 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

   835 	StateMachine().SetState(*nextState);

   836 	delete this;

   837 	return;

   838 	}

   839 	

   840 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::RemoteDeviceDisconnectL(TInt aError)

   841 /**

   842 Remote device has disconnected.

   843 */

   844 	{

   845 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - remote device disconnect received, looks like our requests weren't acceptable, or they just gave up"), &StateMachine());

   846 

   847 	// outstanding async request will be cancelled by state machine when we leave

   848 	User::Leave(aError); // will shutdown the connection

   849 	}	

   850 

   851 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::ShutdownL()

   852 /**

   853 Local device wants us to disconnect

   854 */

   855 	{

   856 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - locally requested disconnect received"), &StateMachine());

   857 	

   858 	// outstanding async request will be cancelled by state machine when we leave

   859 	User::Leave(KErrLocallyInitiatedDisconnect); // will shutdown the connection

   860 	}

   861 	

   862 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::AsyncEventCompleteL()

   863 /**

   864 Timer completion

   865 */

   866 	{

   867 	--iRetries;

   868 

   869 	LOG2(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - async event complete, looks like the timer triggered before they responded.  %d retries remaining..."), &StateMachine(), iRetries);

   870 

   871 	if(iRetries==0)

   872 		{

   873 		LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...disconnecting."), &StateMachine());

   874 		CPanRemDevStateBase* nextState = DoRoleNegotiationFailureL(KErrRemoteDeviceFailedToRespondToRoleRequests);

   875 		StateMachine().SetState(*nextState);

   876 		delete this;

   877 		return;

   878 		}

   879 	else	// resend the role request, and start the timer running again

   880 		{

   881 		LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - ...retrying."), &StateMachine());

   882 		StateMachine().SendRoleRequest(StateMachine().LocalRole(), StateMachine().RemoteRole());

   883 		iTimer.After(StateMachine().Status(), KMaxTimeToWaitForRoleResponse);

   884 		StateMachine().SetActive();

   885 		}

   886 	}

   887 	

   888 void CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::AsyncEventCancelL()

   889 /**

   890 Timer cancel

   891 @note Typically it will be this state that cancels the async event (timer in this case) when we decide we don't need it any longer

   892 */

   893 	{

   894 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation [base]> - async event cancelled, cancelling timer"), &StateMachine());

   895 

   896 	iTimer.Cancel();

   897 	iTimer.Close();

   898 	}

   899 

   900 // This returns a distilled (i.e., not the actual remote device state)

   901 // version of the current connection status of the remote device

   902 TRemoteDeviceState CPanRemDevStatePerformingRoleNegotiationForOutgoingBase::GetState() const

   903 	{

   904 	return EPerformingNegotiation;

   905 	}

   906 	

   907 //

   908 // CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection

   909 //

   910 

   911 CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection::CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

   912 	CPanRemDevStatePerformingRoleNegotiationForOutgoingBase(aStateMachine, EPanRemDevStatePerformingRoleNegotiationForOutgoingConnection)

   913 /**

   914 

   915 */

   916 	{	}

   917 

   918 CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection::CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection(MPanRemDevStateMachineNotify& aStateMachine, TPanRemDevStates aStateNumber) :

   919 	CPanRemDevStatePerformingRoleNegotiationForOutgoingBase(aStateMachine, aStateNumber)

   920 /**

   921 When implementing a new state that derives from this base class, ensure that

   922 it provides a unique number to identify the state from other possible

   923 states.  @see PanAgent::TPanAgtStates.

   924 */

   925 	{	}

   926 

   927 void CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection::OnEntryL()

   928 /**

   929 Send the role request to the remote device

   930 */

   931 	{

   932 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - entering state"), &StateMachine());

   933 	

   934 	User::LeaveIfError(iTimer.CreateLocal());

   935 		

   936 	TInt err;	

   937 	CPanRemDevStateBase* nextState = NULL;

   938 	StateMachine().RemoteRole() = EPanRoleUnknown;	// reset this for outgoing connection - we maybe trying a different role now

   939 	err = StateMachine().InitiateOutgoingConnection(StateMachine().LocalRole(), StateMachine().RemoteRole(), StateMachine().RemoteWorthTryingRolesList());

   940 

   941 	switch(err)

   942 		{

   943 		case KErrNone:

   944 			{

   945 			LOG3(_L("RemDevState[%x]: <performing outgoing role negotiation> - role state machine changed our proposed role; now local: %x, remote: %x"), &StateMachine(), StateMachine().LocalRole(), StateMachine().RemoteRole());

   946 			err = PerformMasterSlaveSwitchIfNecessary(StateMachine().LocalRole());

   947 			

   948 			if(err==KErrWaitingForBasebandRoleSwitch)

   949 				{

   950 				nextState = new(ELeave) CPanRemDevStateWaitingForRoleSwitchForOutgoingConnection(StateMachine());

   951 				break;

   952 				}

   953 			else if(err)

   954 				{

   955 				LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - ...M/S switch required and failed - disconnecting device."), &StateMachine());

   956 				// remote device would not perform role switch (maybe it needs to stay as master for another profile it's using...)

   957 				User::Leave(KErrCouldNotBecomePiconetMaster);

   958 				return;		

   959 				}

   960 				

   961 			StateMachine().SendRoleRequest(StateMachine().LocalRole(), StateMachine().RemoteRole());

   962 			iTimer.After(StateMachine().Status(), KMaxTimeToWaitForRoleResponse);

   963 			StateMachine().SetActive();

   964 			return;

   965 			}

   966 		case KErrLocked:	// someone else is negotiating, so go to the wait state

   967 			{

   968 			LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - role state machine busy, waiting for notification of its availability"), &StateMachine());

   969 			nextState = new(ELeave) CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection(StateMachine());

   970 			break;

   971 			}

   972 

   973 		case KErrInvalidOrUnacceptableRoleCombination:

   974 			LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - this state generated and proposed an illegal role combination"), &StateMachine());

   975 			// fall through

   976 			

   977 		default:

   978 			LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - unexpected response from role state machine"), &StateMachine());

   979 			// if err is something other than KErrNoMemory that might indicate an internal error in the state

   980 			// machine, so ASSERT_DEBUG.  We can probably carry on even if the error is unexpected, as leaving

   981 			// will cause this connection to shutdown.

   982 			User::Leave(err);

   983 		}

   984 		

   985 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

   986 	StateMachine().SetState(*nextState);

   987 	delete this;

   988 	return;

   989 	}

   990 

   991 CPanRemDevStateBase* CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection::DoRoleNegotiationSuccessL()

   992 /**

   993 Role negotiation succeeded, tell role state machine and go to active state

   994 */

   995 	{

   996 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - role negotiation succeeded, going to active state"), &StateMachine());

   997 

   998 	CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStateActive(StateMachine());

   999 	return nextState;

  1000 	}

  1001 	

  1002 CPanRemDevStateBase* CPanRemDevStatePerformingRoleNegotiationForOutgoingConnection::DoRoleNegotiationFailureL(TInt aError)

  1003 /**

  1004 Role negotiation failed, disconnect

  1005 */

  1006 	{

  1007 	LOG1(_L("RemDevState[%x]: <performing outgoing role negotiation> - role negotiation failed, shutting down connection"), &StateMachine());

  1008 	User::Leave(aError);

  1009 	return NULL;	// will never be reached	

  1010 	}

  1011 		

  1012 //

  1013 // CPanRemDevStatePerformingRoleNegotiationForIncomingConnection

  1014 //

  1015 

  1016 CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::CPanRemDevStatePerformingRoleNegotiationForIncomingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

  1017 	CPanRemDevStateBase(aStateMachine, EPanRemDevStatePerformingRoleNegotiationForIncomingConnection)

  1018 /**

  1019 

  1020 */

  1021 	{	}

  1022 

  1023 void CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::OnEntryL()

  1024 /**

  1025 

  1026 */

  1027 	{

  1028 	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - entering state"), &StateMachine());

  1029 

  1030 	// do nothing - just wait for incoming role request

  1031 	}

  1032 

  1033 void CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::BnepRoleRequestFromRemoteDeviceL(const TUUID& aRequestedLocalRole, const TUUID& aRequestedRemoteRole)

  1034 /**

  1035 This is what we're waiting for...

  1036 */

  1037 	{

  1038 //	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - BNEP role request from remote device, they propose local: %S, remote: %S"), &StateMachine(), (aRequestedLocalRole.ShortestForm()), (aRequestedRemoteRole.ShortestForm()));

  1039 

  1040 	TInt err;

  1041 	CPanRemDevStateBase* nextState = NULL;

  1042 	

  1043 	TBluetoothPanRole localRole;

  1044 	TBluetoothPanRole remoteRole;

  1045 	ConvertUuidsToPanRolesL(aRequestedLocalRole, aRequestedRemoteRole, localRole, remoteRole); // will send response to remote device and shutdown the connection if there is an error

  1046 

  1047 	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - checking role request..."), &StateMachine());

  1048 

  1049 	err = StateMachine().IncomingConnectionFromPeer(localRole, remoteRole);

  1050 

  1051 	// store the requested roles, so the next state knows what was asked for

  1052 	StateMachine().LocalRole() = localRole;

  1053 	StateMachine().RemoteRole() = remoteRole;

  1054 

  1055 	switch(err)

  1056 		{

  1057 		case KErrNone:

  1058 			{

  1059 			LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - ...successful, checking to see if M/S switch necessary..."), &StateMachine());

  1060 

  1061 			err = PerformMasterSlaveSwitchIfNecessary(localRole);

  1062 			if(err==KErrWaitingForBasebandRoleSwitch)

  1063 				{

  1064 				nextState = new(ELeave) CPanRemDevStateWaitingForRoleSwitchForIncomingConnection(StateMachine());

  1065 				break;

  1066 				}

  1067 			else if(err)

  1068 				{

  1069 				LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - ...M/S switch required and failed - disconnecting device."), &StateMachine());

  1070 				// remote device would not perform role switch (maybe it needs to stay as master for another profile it's using...)

  1071 				StateMachine().SendRoleResponse(EConnectionNotAllowed);

  1072 				User::Leave(KErrCouldNotBecomePiconetMaster);

  1073 				return;		

  1074 				}

  1075 				

  1076 			LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - ...M/S switch not required, sending successful connect response."), &StateMachine());

  1077 			StateMachine().SendRoleResponse(EOperationSuccessful);

  1078 

  1079 			// Check if the incoming notifier is required.

  1080  			nextState = new(ELeave) CPanRemDevStateIncomingNotification(StateMachine());

  1081 			break;

  1082 			}

  1083 		case KErrLocked:

  1084 			{

  1085 			LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - ...role state machine busy, waiting."), &StateMachine());

  1086 			// and create the "waiting" state

  1087 			nextState = new (ELeave) CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection(StateMachine());

  1088 			break;

  1089 			}

  1090 

  1091 		default:

  1092 			{

  1093 			// An error has occured.  Send a -ve role response and disconnect.

  1094 			LOG2(_L("RemDevState[%x]: <CPanRemDevStatePerformingRoleNegotiationForIncomingConnection> - Fail with error [%d].  Disconnecting peer"), &StateMachine(), err);

  1095 			StateMachine().SendRoleResponse(EConnectionNotAllowed);

  1096 			User::Leave(err);

  1097 			}

  1098 		}

  1099 	

  1100 	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

  1101 	StateMachine().SetState(*nextState);

  1102 	delete this;

  1103 	}

  1104 	

  1105 void CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::BnepRoleResponseFromRemoteDeviceL(TBnepSetupConnectionResponseMessage /*aRoleResponseCode*/)

  1106 /**

  1107 Something's gone wrong - we were expecting a request from the remote device - not a response.

  1108 */

  1109 	{

  1110 	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - BNEP role reponse from remote device - what are they up to?  They're supposed to be sending the role request."), &StateMachine());

  1111 	

  1112 	// drop the role response packet that the remote device has incorrectly sent us

  1113 	}

  1114 	

  1115 void CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::RemoteDeviceDisconnectL(TInt aError)

  1116 /**

  1117 Remote device has disconnected

  1118 */

  1119 	{

  1120 	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - remote device disconnect received, they've obviously given up talking to us."), &StateMachine());

  1121 

  1122 	User::Leave(aError); // will shutdown the connection

  1123 	}

  1124 	

  1125 void CPanRemDevStatePerformingRoleNegotiationForIncomingConnection::ShutdownL()

  1126 /**

  1127 Local device wants us to disconnect

  1128 */

  1129 	{

  1130 	LOG1(_L("RemDevState[%x]: <performing incoming role negotiation> - locally requested disconnect received"), &StateMachine());

  1131 

  1132 	User::Leave(KErrLocallyInitiatedDisconnect); // will shutdown the connection

  1133 	}

  1134 

  1135 // This returns a distilled (i.e., not the actual remote device state)