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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @note PAN agent remote connection state implementations

*/

#include <bluetooth/logger.h>

#include <networking/panuiinterfaces.h>

#include "panagtremdevstates.h"

#include "panagtpolicy.h"

using namespace PanAgent;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_AGENT);

#endif

//

// CPanRemDevStatePerformingSdpQuery

//

CPanRemDevStatePerformingSdpQuery::CPanRemDevStatePerformingSdpQuery(MPanRemDevStateMachineNotify& aStateMachine) :

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

/**

*/

	{

	}

void CPanRemDevStatePerformingSdpQuery::OnEntryL()

/**

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

@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

*/

	{

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

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

	StateMachine().SetActive();

	}

void CPanRemDevStatePerformingSdpQuery::AsyncEventCompleteL()

/**

The SDP query has completed

*/

	{

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

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

	//to it anyway to maximise interoperability

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

		{	

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

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

			{

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

			}

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

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

			{

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

			}

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

		if(StateMachine().WorthTrying())

			{

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

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

			StateMachine().SetState(*nextState);

			delete this;

			}

		else

			{

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

			User::Leave(KErrFixRemoteRoleIsNotSupportedByRemote);

			}

		}

	else // error handling

		{

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

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

		}

	}

void CPanRemDevStatePerformingSdpQuery::AsyncEventCancelL()

/**

The SDP query has been cancelled

*/

	{

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

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

	}

void CPanRemDevStatePerformingSdpQuery::ShutdownL()

/**

The local device wants us to disconnect

*/

	{

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

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

	User::Leave(KErrLocallyInitiatedDisconnect);

	}

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

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

TRemoteDeviceState CPanRemDevStatePerformingSdpQuery::GetState() const

	{

	return EIdle;

	}

//

// CPanRemDevStateConnectingSocket

//

CPanRemDevStateConnectingSocket::CPanRemDevStateConnectingSocket(MPanRemDevStateMachineNotify& aStateMachine) :

	CPanRemDevStateBase(aStateMachine, EPanRemDevStateConnectingSocket)

/**

*/

	{	}

void CPanRemDevStateConnectingSocket::OnEntryL()

/**

*/

	{

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

	TBTServiceSecurity securitySettings;

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

	securitySettings.SetAuthentication(KPanOutgoignAuthenticationRequired);

	securitySettings.SetAuthorisation(KPanOutgoingAuthorisationRequired);

	securitySettings.SetEncryption(KPanOutgoingEncryptionRequired);

	securitySettings.SetUid(KBTPanAuthorisationUid);

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

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

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

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

    User::LeaveIfError(err);

#else

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

#endif

	TUint16 bnepMtu = KBnepMtu;

	TPckg<TUint16> mtuBuf(bnepMtu);

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

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

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

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

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

	StateMachine().SetActive();

	}

void CPanRemDevStateConnectingSocket::AsyncEventCompleteL()

/**

Called when the new socket is connected

*/

	{

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

		{

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

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

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

#else

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

#endif

		StateMachine().OpenPhysicalLinkAdapterL();

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

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        CleanupStack::PushL(nextState);

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

        CleanupStack::Pop();

        nextState = pausedState;

#endif

		StateMachine().SetState(*nextState);

		delete this;

		}

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

		{

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

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

		}

	}	

void CPanRemDevStateConnectingSocket::AsyncEventCancelL()

/**

Cancel the socket connect

*/

	{

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

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

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

	}

void CPanRemDevStateConnectingSocket::ShutdownL()

/**

The local device wants us to disconnect

*/

	{

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

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

	User::Leave(KErrLocallyInitiatedDisconnect);

	}

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

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

TRemoteDeviceState CPanRemDevStateConnectingSocket::GetState() const

	{

	return EIdle;

	}

//

// CPanRemDevStateReconnectingSocket

//

CPanRemDevStateReconnectingSocket::CPanRemDevStateReconnectingSocket(MPanRemDevStateMachineNotify& aStateMachine) :

	CPanRemDevStateBase(aStateMachine, EPanRemDevStateConnectingSocket)

	{	}

/**

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

*/

void CPanRemDevStateReconnectingSocket::OnEntryL()

	{

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

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

	StateMachine().SetRetryConnect();	

	}

/**

	Wait for device to disconnect before attempting reconnect

*/

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

	{

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

	StateMachine().DisconnectBnepChannel();

	TBTServiceSecurity securitySettings;

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

	securitySettings.SetAuthentication(KPanOutgoignAuthenticationRequired);

	securitySettings.SetAuthorisation(KPanOutgoingAuthorisationRequired);

	securitySettings.SetEncryption(KPanOutgoingEncryptionRequired);

	securitySettings.SetUid(KBTPanAuthorisationUid);

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

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

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

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

    User::LeaveIfError(err);

#else

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

#endif

	TUint16 bnepMtu = KBnepMtu;

	TPckg<TUint16> mtuBuf(bnepMtu);

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

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

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

	StateMachine().SetActive();

	}

/**

Called when the new socket is connected

*/

void CPanRemDevStateReconnectingSocket::AsyncEventCompleteL()

	{

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

		{

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

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

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

#else

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

#endif

		StateMachine().OpenPhysicalLinkAdapterL();

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

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        CleanupStack::PushL(nextState);

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

        CleanupStack::Pop();

        nextState = pausedState;

#endif

		StateMachine().SetState(*nextState);

		delete this;

		}

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

		{

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

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

		}

	}	

/**

Cancel the socket connect

*/

void CPanRemDevStateReconnectingSocket::AsyncEventCancelL()

	{

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

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

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

	}

/**

The local device wants us to disconnect

*/

void CPanRemDevStateReconnectingSocket::ShutdownL()

	{

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

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

	User::Leave(KErrLocallyInitiatedDisconnect);

	}

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

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

TRemoteDeviceState CPanRemDevStateReconnectingSocket::GetState() const

	{

	return EIdle;

	}

//

// CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection

//

CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

	CPanRemDevStateBase(aStateMachine, EPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection)

/**

*/

	{	}

void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::OnEntryL()

/**

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

*/

	{	

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

	// do nothing

	}

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

/**

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

*/

	{

	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());

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

	}

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

/**

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

*/

	{

	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());

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

	}

void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::RemoteDeviceDisconnectL(TInt aError)

/**

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

*/

	{

	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());

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

	}

void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::ReadyForRoleRequestL()

/**

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

another device and is now ready for our role request

*/

	{

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

	TInt err;

	CPanRemDevStateBase* nextState = NULL;

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

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

	switch(err)

		{

		case KErrNone:

			{

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

			if(err==KErrWaitingForBasebandRoleSwitch)

				{

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

				break;

				}

			else if(err)

				{

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

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

				User::Leave(KErrCouldNotBecomePiconetMaster);

				return;		

				}

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

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

			break;

			}

		case KErrLocked:

			{

			PanicInState(ERoleStateMachineCalledReadyForRoleRequestThenReturnedLocked);

			break;

			}

		case KErrInvalidOrUnacceptableRoleCombination:

			{

			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());

			User::Leave(KErrInvalidOrUnacceptableRoleCombination);

			}

		default:

			{

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

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

			// will cause this connection to shutdown.

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

			User::Leave(err);

			}

		}

	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

	StateMachine().SetState(*nextState);

	delete this;

	return;

	}

void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::ShutdownL()

/**

Local device wants us to disconnect

*/

	{

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

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

	}

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

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

TRemoteDeviceState CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForOutgoingConnection::GetState() const

	{

	return EPendingNegotiation;

	}

//

// CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection

//

CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection(MPanRemDevStateMachineNotify& aStateMachine) :

	CPanRemDevStateBase(aStateMachine, EPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection)

/**

*/

	{	}

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

	CPanRemDevStateBase(aStateMachine, aStateNumber)

/**

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

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

states.  @see PanAgent::TPanAgtStates.

*/

	{	}

void CPanRemDevStateWaitingForLocalRoleStateMachineAvailabilityForIncomingConnection::OnEntryL()

/**

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

*/

	{	

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

	// do nothing

	}

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

/**

*/

	{

	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());

	// drop resent role request

	}

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

/**

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

*/

	{