// Copyright (c) 2004-2010 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 device class implementation, and remote device state base class implementation

*/

#include <bluetooth/logger.h>

#include "panagtlog.h"

#include "panagtremdev.h"

#include "panagtremdevstates.h"

using namespace PanAgent;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#include <elements/nm_signals.h>

#include "panmessages.h"

using namespace ESock;

using namespace Messages;

#ifdef ESOCK_EXTLOG_ACTIVE

_LIT8(KPanAgtSubTag, "panagt");

#endif

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_AGENT);

#endif

CPanRemoteDeviceStateMachine* CPanRemoteDeviceStateMachine::NewL(RInternalSocket& aConnectedSocket, MRemoteDeviceNotify& aParent, CCommsDbAccess& aDatabase)

/**

Create a new bnep channel in the nif using an already connected socket.

@note This is for incoming connections only.

@param aConnectedSocket A preconnected L2CAP socket ready to hand off to BNEP

@param aParent The class to be notified when events occur

@param aDatabase An handle to the commdb facade to allow us to read records from it

*/

	{

	CPanRemoteDeviceStateMachine* self = new(ELeave) CPanRemoteDeviceStateMachine(aParent, aDatabase);

	CleanupStack::PushL(self);

	self->ConstructL(aConnectedSocket);

	CleanupStack::Pop(self);

	return(self);

	}

CPanRemoteDeviceStateMachine* CPanRemoteDeviceStateMachine::NewL(const TBTDevAddr& aRemDevAddr, MRemoteDeviceNotify& aParent, CCommsDbAccess& aDatabase)

/**

Create a new BNEP channel in the nif by connecting a socket and passing it across.

@note This is for outgoing connections only.

@param aRemDevAddr A preconnected L2CAP socket ready to hand off to BNEP

@param aParent The class to be notified when events occur

@param aDatabase An handle to the commdb facade to allow us to read records from it

*/

	{

	CPanRemoteDeviceStateMachine* self = new(ELeave) CPanRemoteDeviceStateMachine(aParent, aDatabase);

	CleanupStack::PushL(self);

	self->ConstructL(aRemDevAddr);

	CleanupStack::Pop(self);

	return(self);

	}

CPanRemoteDeviceStateMachine::CPanRemoteDeviceStateMachine(MRemoteDeviceNotify& aParent, CCommsDbAccess& aDatabase) :

	CActive(KPanAgtAoPriority), iParent(aParent), iDatabase(aDatabase)

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    NM_LOG_NODE_CREATE(KPanAgtSubTag, CPanRemoteDeviceStateMachine);

#endif

	CONNECT_LOGGER

	CActiveScheduler::Add(this);

	}

void CPanRemoteDeviceStateMachine::ConstructL(const TBTDevAddr& aRemDevAddr)

/**

Connect a new socket and create a BNEP channel to use it.

@note This happens for outgoing connections only.

*/

	{

	iRemSockAddr.SetBTAddr(aRemDevAddr);

	iRemSockAddr.SetPort(KBnepPsm);

	User::LeaveIfError(iSockServ.Connect());

#ifdef __FLOG_ACTIVE

	TBuf<KMaxBtAddrSize> tempDevAddrBuf;

	iRemSockAddr.BTAddr().GetReadable(tempDevAddrBuf, KNullDesC, KBtAddrSeparator, KNullDesC);

	LOG2(_L("RemDev[%x]: connected to %S"), this, &tempDevAddrBuf);

#endif

	// preallocate the shutdown state

	iShutdownState = new(ELeave) CPanRemDevStateShutdown(*this);

	LOG(_L("RemDevStateMachine - Deciding whether to perform SDP query"));

	TBool sdpQueriesDisabledStatus;

	Database().GetBoolL(TPtrC(PAN_SERVICE_EXTENSIONS), TPtrC(PAN_DISABLE_SDP_QUERY), sdpQueriesDisabledStatus);

	SdpQueriesDisabled(sdpQueriesDisabledStatus);

	// if we're allowed to use SDP, then perform the SDP query

	CPanRemDevStateBase* nextState;

	if(!IsSdpQueriesDisabled())

		{

		// open an SDP query subsession	

		LOG(_L("RemDevStateMachine - Connected to remote SDP querier"));

		User::LeaveIfError(RemoteSdpQuerier().Open());

		nextState = new(ELeave) CPanRemDevStatePerformingSdpQuery(*this);

		}

	else	// SDP queries are inhibited by setting in commdb

		{	

		LOG(_L("RemDevStateMachine  - SDP query inhibited by commdb settings"));

		nextState = new(ELeave) CPanRemDevStateConnectingSocket(*this);

		}

	SetState(*nextState);

	}

void CPanRemoteDeviceStateMachine::ConstructL(RInternalSocket& aConnectedSocket)

/**

Take a preconnected socket and create a BNEP channel to use it.

@note This happens for incoming connections only.

*/

	{

	User::LeaveIfError(iSocket.Transfer(aConnectedSocket)); // take ownership of the socket, so that the initial state can perform actions on it

	// make a note of the remote device address

	iSocket.RemoteName(iRemSockAddr);

	User::LeaveIfError(iSockServ.Connect());

#ifdef __FLOG_ACTIVE

	TBuf<KMaxBtAddrSize> tempDevAddrBuf;

	iRemSockAddr.BTAddr().GetReadable(tempDevAddrBuf, KNullDesC, KBtAddrSeparator, KNullDesC);

	LOG2(_L("RemDev[%x]: connected to %S"), this, &tempDevAddrBuf);

#endif

	// preallocate the shutdown state

	iShutdownState = new(ELeave) CPanRemDevStateShutdown(*this);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    // Create the states first so if we Leave no message is sent to BNEP

	CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStatePerformingRoleNegotiationForIncomingConnection(*this);

    CleanupStack::PushL(nextState);

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

    CleanupStack::Pop();

	SetState(*pausedState);

    CreateNewBnepConnection(iSocket, TPanMessage::EActivityCreateChannelControllerForIncoming);

	OpenPhysicalLinkAdapterL();

#else

// !SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	// create the connection

	CreateNewBnepConnectionL(iSocket);

	OpenPhysicalLinkAdapterL();

	CPanRemDevStateBase* nextState = new(ELeave) CPanRemDevStatePerformingRoleNegotiationForIncomingConnection(*this);

	SetState(*nextState);

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	}

CPanRemoteDeviceStateMachine::~CPanRemoteDeviceStateMachine()

/**

Delete the last state on the way out, and tidy up various other bits and pieces

*/

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	__ASSERT_DEBUG(iBnepChannelController == TNodeId::NullId(), PanAgentPanic(EDeletingRemoteDeviceWithoutDisconnecting));

#else

	__ASSERT_DEBUG(!iBnepChannelController, PanAgentPanic(EDeletingRemoteDeviceWithoutDisconnecting));

#endif

	__ASSERT_DEBUG(iState, PanAgentPanic(ENoStateOnExit));

	__ASSERT_DEBUG(!IsActive(), PanAgentPanic(EStillActiveOnExit));

	Cancel(); // in release builds, cancel the outstanding request

#ifndef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	if(iBnepChannelController)

		iBnepChannelController->Close();

#endif

	delete iState;

	iState = NULL;

	__ASSERT_DEBUG(!iShutdownState, PanAgentPanic(ERemoteDeviceDidNotUsePreallocatedShutdownState));

	// everyone should be shutting down by leaving from the appropriate method and letting the 

	// state machine clean up/shut down the connection.  If this pointer is not NULL, it suggests

	// that someone's created the shutdown state directly (which can fail in OOM situations)

	delete iShutdownState; // delete the shutdown state if it exists

	iSocket.Close(); // shouldn't be open, but just in case

	iPhysicalLinkAdapter.Close();

	iRemoteSdpQuerier.Close();

	iSockServ.Close();

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    NM_LOG_NODE_DESTROY(KPanAgtSubTag, CPanRemoteDeviceStateMachine);

#endif

    CLOSE_LOGGER

	}

//

// CActive methods

//

void CPanRemoteDeviceStateMachine::RunL()

/**

Called when the new socket is connected

@note Only used when creating a new socket for an outgoing connection

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->AsyncEventCompleteL());

	if(err)

		{

		Shutdown(err);

		}

	}

void CPanRemoteDeviceStateMachine::DoCancel()

/**

Cancel the connection

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->AsyncEventCancelL());

	if(err)

		{

		Shutdown(err);

		}

	}

//

// Other state machine downcall methods

//

void CPanRemoteDeviceStateMachine::ReadyForRoleRequest()

/**

Pass the request from the local device to the appropriate control channel.

Called from the state machine when it's ready to negotiate roles for this connection

@note This can be called when the connection is active, and indicates that the state machine wants to renegotiate roles

@note Clients must set a flag and initiate a callback to start the RoleRequest() process to prevent call stacks from getting too large

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->ReadyForRoleRequestL());

	if(err)

		{

		Cancel();	// cancel any outstanding async requests that states may have had running before shutting down

					// note - not all states use async requests, so this may have no effect

		Shutdown(err);

		}

	}

void CPanRemoteDeviceStateMachine::Disconnect()

/**

Locally initiated disconnect

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->ShutdownL());	

	if(err)

		{

		Cancel();	// cancel any outstanding async requests that states may have had running before shutting down

					// note - not all states use async requests, so this may have no effect

		Shutdown(err);

		}

	}

TInt CPanRemoteDeviceStateMachine::DisallowRoleSwitch()

/**

Change the link policy to prevent other devices performing master/slave switches

@note This is intended to lock us in the master role

*/

	{

	TInt err = iPhysicalLinkAdapter.PreventRoleSwitch();

#ifdef __FLOG_ACTIVE

	TBuf<KMaxBtAddrSize> tempDevAddrBuf;

	iRemSockAddr.BTAddr().GetReadable(tempDevAddrBuf, KNullDesC, KBtAddrSeparator, KNullDesC);

	LOG2(_L("RemDev[%S]: ...prevent role change returned %d"), &tempDevAddrBuf, err);

#endif

	return err;

	}

TInt CPanRemoteDeviceStateMachine::AllowRoleSwitch()

/**

Change the link policy to allow other devices to perform master/slave switches

*/

	{

	TInt err = iPhysicalLinkAdapter.AllowRoleSwitch();

#ifdef __FLOG_ACTIVE

	TBuf<KMaxBtAddrSize> tempDevAddrBuf;

	iRemSockAddr.BTAddr().GetReadable(tempDevAddrBuf, KNullDesC, KBtAddrSeparator, KNullDesC);

	LOG2(_L("RemDev[%S]: ...allow role change returned %d"), &tempDevAddrBuf, err);

#endif

	return err;

	}

TBTDevAddr CPanRemoteDeviceStateMachine::DevAddr() const

/**

Return the device address of the remote device

*/

	{

	return(iRemSockAddr.BTAddr());

	}

//

// MPanConnectionNotify methods

//

void CPanRemoteDeviceStateMachine::BnepRoleRequestFromRemoteDevice(const TUUID& aRequestedLocalRole, const TUUID& aRequestedRemoteRole)

/**

Request from remote device for given BNEP roles

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->BnepRoleRequestFromRemoteDeviceL(aRequestedLocalRole, aRequestedRemoteRole));

	if(err)

		{

		Cancel();	// cancel any outstanding async requests that states may have had running before shutting down

					// note - not all states use async requests, so this may have no effect

		Shutdown(err);

		}

	}

void CPanRemoteDeviceStateMachine::BnepRoleResponseFromRemoteDevice(TBnepSetupConnectionResponseMessage aRoleResponseCode)

/**

Response from remote device to our request for BNEP roles

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->BnepRoleResponseFromRemoteDeviceL(aRoleResponseCode));

	if(err)

		{

		Cancel();	// cancel any outstanding async requests that states may have had running before shutting down

					// note - not all states use async requests, so this may have no effect

		Shutdown(err);

		}

	}

void CPanRemoteDeviceStateMachine::SetRetryConnect()

	{

	iParent.SetRetryConnect(*this);

	}

void CPanRemoteDeviceStateMachine::RemoteDeviceDisconnect(TInt aError)

/**

The remote device has disconnected

*/

	{

	__ASSERT_ALWAYS(iState, PanAgentPanic(ENoRemDevState));

	TRAPD(err, iState->RemoteDeviceDisconnectL(aError));

	if(err)

		{

		Cancel();	// cancel any outstanding async requests that states may have had running before shutting down

					// note - not all states use async requests, so this may have no effect

		Shutdown(err);

		}

	}

TInt CPanRemoteDeviceStateMachine::IncrementConnectionRetryAttempts()

	{

	return iConnectionRetryAttempts++;

	}

void CPanRemoteDeviceStateMachine::ResetConnectionRetryAttempts()

	{

	iConnectionRetryAttempts = 0;

	}

void CPanRemoteDeviceStateMachine::ResetRetryParameters()

	{

	iRemoteWorthTryingRoles.ResetWorthTryingRoles();

	}

TBool CPanRemoteDeviceStateMachine::WorthTrying()

	{

	LOG(_L("CPanRemoteDeviceStateMachine::WorthTrying"));

	TBool retval = EFalse; 	// assume its not worth retrying until we prove otherwise

	if(iParent.WorthTrying(iRemoteWorthTryingRoles))

		{

		if (RemoteWorthTryingRolesList().IsWorthTryingU())

			{

			retval = ETrue;

			}

		else if (RemoteWorthTryingRolesList().IsWorthTryingGn())

			{

			retval = ETrue;

			}

		else if (RemoteWorthTryingRolesList().IsWorthTryingNap())

			{

			retval = ETrue;

			}

		}

	return(retval);

	}

TRemoteDeviceState CPanRemoteDeviceStateMachine::GetState() const

	{

	TRemoteDeviceState state = EIdle;

	if(iState)

		{

		state = iState->GetState();

		}

	return state;

	}

TBool CPanRemoteDeviceStateMachine::NewConnectedDeviceProgressSent() const

	{

	return iNewConnectedDeviceProgressSent;

	}

void CPanRemoteDeviceStateMachine::SetNewConnectedDeviceProgressSent(TBool aNewConnectedDeviceProgressSent)

	{

	iNewConnectedDeviceProgressSent = aNewConnectedDeviceProgressSent;

	}

#ifndef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

MPanLinkControlBase& CPanRemoteDeviceStateMachine::BnepConnectionController() 

	{

	return iParent.BnepConnectionController();

	}

#endif

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

/**

*/

void CPanRemoteDeviceStateMachine::ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& /* aRecipient */, Messages::TSignatureBase& aCFMessage)

    {

	if (aCFMessage.MessageId().Realm() == TPanMessage::ERealmId)

    	{

        switch (aCFMessage.MessageId().MessageId())

            {

            case TPanMessage::TChannelControllerCreated::EId:

                {

                const TNodeCtxId& ctxId = address_cast<TNodeCtxId> (aSender);

                TUint activityId = ctxId.NodeCtx();

                TPanMessage::TChannelControllerCreated& msg = message_cast<TPanMessage::TChannelControllerCreated>(aCFMessage);

                if (activityId == TPanMessage::EActivityCreateChannelControllerForIncoming) 

                    {

                    // We now know that the socket has been transfered, or an error has occured

                    // and that either way it is now safe for the incoming connection listener

                    // to continue accepting connections

                    iParent.RestartIncomingConnectionListener(msg.iValue);

                    }

                if (msg.iValue == KErrNone) 

                    {

                    // Channel controller created - transition into whatever next

                    // state is waiting

                    iBnepChannelController = aSender;

                    // We would expect that iState should always be the paused state when

                    // we get here. We assert it in debug builds in case something we

                    // haven't accounted for changes it unexpectedly

                    __ASSERT_DEBUG(iState->iStateNumber == CPanRemDevStateBase::EPanRemDevStatePaused, PanAgentPanic(EPanAgtUnexpectedStateChange));

                    if (iState->iStateNumber == CPanRemDevStateBase::EPanRemDevStatePaused)

                        {

                        // Calling AsyncEventCompleteL() on the paused state will make it

                        // transition to the real state, start its OnEntryL() processing 

                        TRAPD(err, iState->AsyncEventCompleteL());

                        if (err != KErrNone)

                            {

                            Shutdown(err);

                            }

                        }

                    }

                else

                    {

                    // Error handling for the TCreateChannelController

                    if (activityId == TPanMessage::EActivityCreateChannelControllerForIncoming)

                        {

                        // For outgoing (initial connect or retry connect) the handling should

                        // be a call to Shutdown(msg.iValue);

                        Shutdown(msg.iValue);                        

                        }

                    else if (activityId != TPanMessage::EActivityCreateChannelControllerForIncoming)

                        {

                        __ASSERT_DEBUG(EFalse, PanAgentPanic(EPanAgtUnexpectedMessage));

                        }

                    }

                }

                break;

            case TPanMessage::TRoleRequestFromRemoteDevice::EId:

                {

                TPanMessage::TRoleRequestFromRemoteDevice& msg = message_cast<TPanMessage::TRoleRequestFromRemoteDevice>(aCFMessage);

                BnepRoleRequestFromRemoteDevice(msg.iRequestedLocalRole, msg.iRequestedRemoteRole);

                }

                break;

            case TPanMessage::TRoleResponseFromRemoteDevice::EId:

                {

                TPanMessage::TRoleResponseFromRemoteDevice& msg = message_cast<TPanMessage::TRoleResponseFromRemoteDevice>(aCFMessage);

                BnepRoleResponseFromRemoteDevice(msg.iSetupResponse);

                }

                break;

            case TPanMessage::TRemoteDeviceDisconnect::EId: