// 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 role state machine state implementations

*/

#include <bluetooth/logger.h>

#include "panagtstates.h"

#include "panagtremdev.h"

#include "panlocalsdphelper.h"

#include "BTSec.h"

using namespace PanAgent;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_AGENT);

#endif

CPanAgtStateBase* CPanAgtStateUninitialised::NewL(MPanAgtStateMachineNotify& aStateMachine)

	{

	CPanAgtStateUninitialised* self = new (ELeave) CPanAgtStateUninitialised(aStateMachine);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop();

	return self;

	}

void CPanAgtStateUninitialised::OnEntryL()

	{	

	}

CPanAgtStateUninitialised::CPanAgtStateUninitialised(MPanAgtStateMachineNotify& aStateMachine) :

	CPanAgtStateBase(aStateMachine, EPanAgentStateUninitialised)

	{

	}

//

// CPanAgentStateInitialising

//

CPanAgentStateInitialising::CPanAgentStateInitialising(MPanAgtStateMachineNotify& aStateMachine) :

	CPanAgtStateBase(aStateMachine, EPanAgentStateInitialising)

/**

*/

	{	}

CPanAgtStateBase* CPanAgentStateInitialising::NewL(MPanAgtStateMachineNotify& aStateMachine)

	{

	CPanAgentStateInitialising* self = new (ELeave) CPanAgentStateInitialising(aStateMachine);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop();

	return self;

	}

void CPanAgentStateInitialising::OnEntryL()

/**

*/

	{

	__ASSERT_DEBUG(ActiveDeviceCount()==0, PanicInState(EActiveDevicesInArrayInInitialisingState));

	__ASSERT_DEBUG(NegotiatingDeviceCount()==0, PanicInState(ENegotiatingDevicesInArrayInInitialisingState));

	LOG(_L("RoleState: <initialising> - entering state"));

	// Have a look in commdb to see if we have a defined local role

	TUint32 roleTemp;

	StateMachine().Database().GetIntL(TPtrC(PAN_SERVICE_EXTENSIONS), TPtrC(PAN_LOCAL_ROLE), roleTemp);

	__ASSERT_DEBUG(roleTemp!=0xffff, PanicInState(EOldFormatPanRoleBeingUsedInCommdb));

	StateMachine().FixedLocalRole() = static_cast<TBluetoothPanRole>(roleTemp);

	LOG1(_L("RoleState: <initialising> - local device state in commdb is %x"), StateMachine().FixedLocalRole());

	// same thing for remote role

	StateMachine().Database().GetIntL(TPtrC(PAN_SERVICE_EXTENSIONS), TPtrC(PAN_PEER_ROLE), roleTemp);

	__ASSERT_DEBUG(roleTemp!=0xffff, PanicInState(EOldFormatPanRoleBeingUsedInCommdb));

	StateMachine().FixedRemoteRole() = static_cast<TBluetoothPanRole>(roleTemp);

	LOG1(_L("RoleState: <initialising> - remote device state in commdb is %x"), StateMachine().FixedRemoteRole());

	// Check if PAN NAP is allowed as a local role.

	TBool napEnabled = EFalse;

	TRAP_IGNORE(StateMachine().Database().GetBoolL(TPtrC(PAN_SERVICE_EXTENSIONS), TPtrC(PAN_NAP_SERVICE_ENABLED), napEnabled));

	StateMachine().SetNapEnabled(napEnabled);	

	// Check for incoming connection support and enable if necessary

	TBool allowIncoming;

	StateMachine().Database().GetBoolL(TPtrC(PAN_SERVICE_EXTENSIONS), TPtrC(PAN_ALLOW_INCOMING), allowIncoming);

	StateMachine().SetAllowIncoming(allowIncoming);	

	// make sure the fixed roles (if there are any) make sense

	User::LeaveIfError(IsRoleRequestValid(StateMachine().FixedLocalRole(), StateMachine().FixedRemoteRole()));

	if(napEnabled)

		{

		// NAP can only be enabled for a listening IAP.

		if(!allowIncoming) 

			{

			LOG(_L("RoleState: <initialising> - Listening must be enabled when NAP is enabled.  Fail initialisation"));

			User::Leave(KErrArgument);

			}

		if(!(StateMachine().FixedLocalRole() == EPanRoleUnknown || StateMachine().FixedLocalRole() == EPanRoleNap))

			{

			LOG1(_L("RoleState: <initialising> - Invalid Fixed Local Role %x"), StateMachine().FixedLocalRole());

			User::Leave(KErrArgument);

			}

		}

	else

		{

		if(StateMachine().FixedLocalRole() == EPanRoleNap)

			{

			LOG(_L("RoleState: <initialising> - Invalid Fixed Local Role PAN-NAP when NAP not enabled"));

			User::Leave(KErrArgument);

			}

		}

	if(allowIncoming)

		{

		// Only any point in advertising in SDP if we're allowing incoming connections...

		LOG(_L("RoleState: <initialising> - incoming support is enabled"));

		if(StateMachine().FixedLocalRole() == EPanRoleU)

			{

			LOG(_L("RoleState: <initialising> - Invalid PAN-U Fixed Local Role for listening IAP"));

			User::Leave(KErrArgument);

			}

		if(!(StateMachine().FixedRemoteRole() == EPanRoleUnknown || StateMachine().FixedRemoteRole() == EPanRoleU))

			{

			LOG1(_L("RoleState: <initialising> - Invalid Fixed Remote Role for listening IAP %x"), StateMachine().FixedRemoteRole());

			User::Leave(KErrArgument);

			}

		//If other services are active currently, we will not register sdp records and open listen socket

		if (StateMachine().IsNewPanConnectionAllowed())

			{

			StartListenerL();

			}

		}

#ifdef _DEBUG

	else  	// no incoming support, so just start outgoing connections and move to idle state

			// if incoming support is enabled, this will be done after all the SDP roles are registered

		{

		LOG(_L("RoleState: <initialising> - incoming support is disabled"));

		}

#endif		

	DoStartOutgoingL();

	}

void CPanAgentStateInitialising::DoStartOutgoingL()

/**

Start setting up outgoing connections, and move to the idle state

*/

	{

	if(StateMachine().SuppressOutgoing())	// check that outgoing connections are not suppressed 

											// (to allow UIs to start the ad-hoc IAP in incoming mode only,

											// and to allow reuse of the registering SDP records state to 

											// perform reregistration of SDP records - when reregistering

											// records, we don't want to prompt to start an outgoing connection)

		{

		LOG(_L("RoleState: <initialising/registering local SDP records> - outgoing connections suppressed, resetting suppression flag and moving directly to idle state"));

		StateMachine().ResetSuppressOutgoing(); // stop future outgoing connections being suppressed

		if(!(StateMachine().IsIncomingConnectionListenerEnabled()))

			{

			LOG(_L("RoleState: <initialising/registering local SDP records> - This is an invalid state while outgoing connection is suppressed without incoming listening enabled."));

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

			User::Leave(KErrListenForIncomingConnectionRequestedWithoutListeningSupport);

			}

		}

	else

		{

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

		StateMachine().SetupOutgoingConnectionsL();

		}

	CPanAgtStateBase* nextState = CPanAgtStateIdle::NewL(StateMachine());			

	StateMachine().SetState(*nextState);

	delete this;

	return;

	}

//

// CPanAgtStateIdle

//

CPanAgtStateBase* CPanAgtStateIdle::NewL(MPanAgtStateMachineNotify& aStateMachine)

	{

	CPanAgtStateIdle* self = new (ELeave) CPanAgtStateIdle(aStateMachine);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop();

	return self;

	}

CPanAgtStateIdle::CPanAgtStateIdle(MPanAgtStateMachineNotify& aStateMachine) :

	CPanAgtStateBase(aStateMachine, EPanAgtStateIdle)

/**

*/

	{	}

void CPanAgtStateIdle::OnEntryL()

/**

*/

	{

	__ASSERT_DEBUG(ActiveDeviceCount()==0, PanicInState(EActiveDevicesInArrayInInitialisingState));

	__ASSERT_DEBUG(NegotiatingDeviceCount()==0, PanicInState(ENegotiatingDevicesInArrayInInitialisingState));

	LOG(_L("RoleState: <idle> - entering state"));

	StateMachine().SendProgress(EPanAgtIdle, KErrNone);

	StartNegotiationWithFirstPendingDevice(); // if there's not already a device negotiating, start one negotiating

	}

void CPanAgtStateIdle::InitiateOutgoingConnectionL(TBluetoothPanRole& aRequestedLocalRole, TBluetoothPanRole& aRequestedRemoteRole, TPanDeviceWorthTryingRolesList& aWorthTryingRemoteRoles)

/**

*/

	{	

	LOG(_L("RoleState: <idle> - InitiateOutgoingConnectionL"));

	LOG3(_L("RoleState: <idle> - ...worthTrying roles - U:%x GN:%x NAP:%x..."), aWorthTryingRemoteRoles.IsWorthTryingU(), aWorthTryingRemoteRoles.IsWorthTryingGn(), aWorthTryingRemoteRoles.IsWorthTryingNap());

	// Determine the roles for this outgoing connection.

	aRequestedLocalRole = StateMachine().FixedLocalRole(); 

	if(aRequestedLocalRole == EPanRoleUnknown)

		{

		aRequestedLocalRole = EPanRoleU;

		}

	// aRequestedLocalRole should be set to the local role we want to be by the time we call the method below

	User::LeaveIfError(SelectRemoteRoleBasedOnLocalRole(aRequestedLocalRole, aRequestedRemoteRole, aWorthTryingRemoteRoles));

	// and now transition to the appropriate state

	CPanAgtStateBase* nextState = NULL;

	switch(aRequestedLocalRole)

		{

		case EPanRoleU:

			{

			// What about a multiple start case where there are several devices started at once,

			// you may be asking?

			// This is the wrong state to go into then...  However, if they all arrive in the 

			// outgoing connection starter at the same time (which they will), then they'll all 

			// get dumped into the array sychronously, and since each one has to asyhronously

			// connect a socket, by the time they call us for their role request, we'll know 

			// there's >1 device

			nextState = CPanAgtStateNegotiatingURole::NewL(StateMachine());

			break;			

			}

		case EPanRoleGn:

		case EPanRoleNap:

			{

			nextState = CPanAgtStateNegotiatingGnOrNapRole::NewL(StateMachine());

			break;

			}

		default:

			{

			PanicInState(EPanAgentRoleStateMachineInvalidLocalRole);

			break;

			}

		}

	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

	StateMachine().SetState(*nextState);

	delete this;

	}

void CPanAgtStateIdle::DeviceDisconnectedL(CPanRemoteDeviceStateMachine& aDevice)

/**

A remote device has disconnected before it even began role negotiation!  Obviously something dodgy about their role request...

*/

	{

	DoDeviceDisconnectL(aDevice);

	}

void CPanAgtStateIdle::IncomingConnectionFromPeerL(TBluetoothPanRole aLocalRole)

	{

	CPanAgtStateBase* nextState = NULL;

	switch(aLocalRole)

		{

		case EPanRoleU:

			{

			nextState = CPanAgtStateNegotiatingURole::NewL(StateMachine());

			break;			

			}

		case EPanRoleGn:

		case EPanRoleNap:

			{

			nextState = CPanAgtStateNegotiatingGnOrNapRole::NewL(StateMachine());

			break;

			}

		default:

			PanicInState(EInvalidRoleForIncomingConnectionFromPeerL);

		}

	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

	StateMachine().SetState(*nextState);

	delete this;

	}

//

// CPanAgtStateNegotiatingURole

//

CPanAgtStateBase* CPanAgtStateNegotiatingURole::NewL(MPanAgtStateMachineNotify& aStateMachine)

	{

	CPanAgtStateNegotiatingURole* self = new (ELeave) CPanAgtStateNegotiatingURole(aStateMachine);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop();

	return self;

	}

CPanAgtStateNegotiatingURole::CPanAgtStateNegotiatingURole(MPanAgtStateMachineNotify& aStateMachine) :

	CPanAgtStateBase(aStateMachine, EPanAgtStateNegotiatingURole)

/**

*/

	{	}

CPanAgtStateNegotiatingURole::CPanAgtStateNegotiatingURole(MPanAgtStateMachineNotify& aStateMachine, TPanAgtStates aStateNumber) :

	CPanAgtStateBase(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 CPanAgtStateNegotiatingURole::OnEntryL()

/**

Start deregistering unwanted local SDP records

*/

	{

	__ASSERT_DEBUG(ActiveDeviceCount()==0, PanicInState(EActiveDevicesInArrayInNegotiatingPanUState));

	__ASSERT_DEBUG(NegotiatingDeviceCount()==1, PanicInState(EMoreThanOneDeviceInNegotiatingModeInArray));

	LOG(_L("RoleState: <negotiating U> - entering state"));

	if(StateMachine().AllowIncoming())

		{

		// stop advertising U record

		StateMachine().PanLocalSdpRegistrar().UnregisterLocalSdpRecord(EPanRoleU);

		}

	}

void CPanAgtStateNegotiatingURole::InitiateOutgoingConnectionL(TBluetoothPanRole& /*aRequestedLocalRole*/, TBluetoothPanRole& /*aRequestedRemoteRole*/, TPanDeviceWorthTryingRolesList& /*aWorthTryingRemoteRoles*/)

/**

Don't accept more role requests when we're negotiating

*/

	{

	LOG(_L("RoleState: <negotiating U> - InitiateOutgoingConnectionL to another device, returning busy"));

	User::Leave(KErrLocked);

	}

void CPanAgtStateNegotiatingURole::IncomingConnectionFromPeerL(TBluetoothPanRole /*aLocalRole*/)

	{

	LOG(_L("RoleState: <negotiating U> - IncomingConnectionFromPeerL , returning busy"));

	User::Leave(KErrLocked);

	}

void CPanAgtStateNegotiatingURole::DeviceActiveL(CPanRemoteDeviceStateMachine& aDevice)

/**

A device has finished negotiation and is now active

*/

	{

	__ASSERT_ALWAYS(FindDeviceInArray(aDevice)>=0, PanicInState(EDeviceAttemptingToNegotiateThatIsNotInArray));

	__ASSERT_DEBUG(aDevice.GetState() == EActive, PanicInState(EDeviceActiveCalledByDeviceNotInActiveState));

	CPanAgtStateBase* nextState = CPanAgtStateURole::NewL(StateMachine());		

	StateMachine().SetState(*nextState);

	delete this;

	}

void CPanAgtStateNegotiatingURole::DeviceDisconnectedL(CPanRemoteDeviceStateMachine& aDevice)

/**

A device has disconnected

*/

	{

	//This function will only be called when device is in EDisconnecting State.

	//Remote device state machine will first shutdown itself and then call panagent to

	//disconnect this device and remove it from the device array

	__ASSERT_DEBUG(aDevice.GetState() == EDisconnecting, PanicInState(EInvalidRemoteDeviceState));

	// disconnect them and shutdown or return to the idle state

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

	DoDeviceDisconnectL(aDevice); // will leave and shutdown the connection if necessary

		StartListenerL();

	CPanAgtStateBase* nextState = CPanAgtStateIdle::NewL(StateMachine());

	StateMachine().SetState(*nextState);

	delete this;

	return;

	}

//

// CPanAgtStateURole

//

CPanAgtStateBase* CPanAgtStateURole::NewL(MPanAgtStateMachineNotify& aStateMachine)

	{

	CPanAgtStateURole* self = new (ELeave) CPanAgtStateURole(aStateMachine);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop();

	return self;

	}

CPanAgtStateURole::CPanAgtStateURole(MPanAgtStateMachineNotify& aStateMachine) :

	CPanAgtStateBase(aStateMachine, EPanAgtStateURole)

/**

*/

	{	}

void CPanAgtStateURole::OnEntryL()

/**

*/

	{

	__ASSERT_DEBUG(NegotiatingDeviceCount()==0,PanicInState(EDeviceInNegotiatingModeOnEntryToUState));

	__ASSERT_DEBUG(ActiveDeviceCount()==1, PanicInState(ETooManyDevicesAttachedInURole));

	LOG(_L("RoleState: <U role> - entering state"));

	StateMachine().SendProgress(EPanAgtURole, KErrNone);

	StartNegotiationWithFirstPendingDevice();

	}

void CPanAgtStateURole::InitiateOutgoingConnectionL(TBluetoothPanRole& /*aRequestedLocalRole*/, TBluetoothPanRole& /*aRequestedRemoteRole*/, TPanDeviceWorthTryingRolesList& /*aWorthTryingRemoteRoles*/)

	{

	// Need to become GN / NAP.  Check that this will be acceptable for the fixed roles

	if(StateMachine().FixedLocalRole() == EPanRoleU || 

	   (StateMachine().FixedRemoteRole() == EPanRoleNap || StateMachine().FixedRemoteRole() == EPanRoleGn))

		{

		User::Leave(KErrInvalidOrUnacceptableRoleCombination);

		}

	else

		{

		CPanAgtStateBase* nextState = CPanAgtStateRenegotiatingActiveConnectionToGnOrNapRoleAtOurBehest::NewL(StateMachine());

		StateMachine().SetState(*nextState);

		delete this;

		User::Leave(KErrLocked);

		}

	}

void CPanAgtStateURole::IncomingConnectionFromPeerL(TBluetoothPanRole aLocalRole)

	{

	if(aLocalRole == EPanRoleU)

		{

		// An existing connection is established to the PAN-U role.

		User::Leave(KErrInvalidOrUnacceptableRoleCombination);

		}

	// Start upgrade to GN/NAP

	CPanAgtStateBase* nextState = CPanAgtStateRenegotiatingActiveConnectionToGnOrNapRoleAtOurBehest::NewL(StateMachine());

	StateMachine().SetState(*nextState);

	delete this;

	User::Leave(KErrLocked); // hold the new device off until we've renegotiated with the existing one			

	}

void CPanAgtStateURole::RoleChangeRequestFromPeerL(TBluetoothPanRole aLocalRole)

	{

	CPanAgtStateBase* nextState = NULL;

	switch(aLocalRole)

		{

		case EPanRoleU:

			nextState = CPanAgtStateRenegotiatingActiveConnectionToURoleAtPeersBehest::NewL(StateMachine());

			break;

		case EPanRoleGn:

		case EPanRoleNap:

			nextState = CPanAgtStateRenegotiatingActiveConnectionToGnOrNapRoleAtPeersBehest::NewL(StateMachine());

			break;

		default:

			PanicInState(EInvalidLocalRoleFromRoleChangeRequestFromPeer);

		}

	__ASSERT_ALWAYS(nextState, PanicInState(ENoNextStateSet));

	StateMachine().SetState(*nextState);

	delete this;

	}

#ifdef _DEBUG

void CPanAgtStateURole::DeviceActiveL(CPanRemoteDeviceStateMachine& aDevice)

#else

void CPanAgtStateURole::DeviceActiveL(CPanRemoteDeviceStateMachine& /*aDevice*/)

#endif // _DEBUG

/**

@note This is only allowed if it's the same device as we're already attached to 

ie. we're performing a role switch

*/

	{

	__ASSERT_DEBUG(aDevice.GetState() == EPerformingNegotiation, PanicInState(EUnexpectedDeviceActiveReceivedByState));

	}

void CPanAgtStateURole::DeviceDisconnectedL(CPanRemoteDeviceStateMachine& aDevice)

/**

A remote device has completed its shutdown

*/

	{

	LOG(_L("RoleState: <U role> - device disconnected..."));

	DoDeviceDisconnectL(aDevice); // if there are no devices in the array and we're not supporting incoming connection this method will leave

	// This could be the on device connected to the U or it could be a failed upgrade device.

	if(StateMachine().Devices().Count() == 0)

		{

		StartListenerL();

		CPanAgtStateBase* nextState = CPanAgtStateIdle::NewL(StateMachine());

		StateMachine().SetState(*nextState);

		delete this;

		}

	}

void CPanAgtStateURole::StateSendRoleNotification()

	{