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

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include <comms-infras/nifif.h> // should be removed once KCOGetAgentEMIPtr is defined in nifagt.h

#include <elements/nm_interfaces.h>

#include "panagtlog.h"

#include "panagt.h"

#include "panagtremdev.h"

#include "panagtstates.h"

#include "panlocalsdphelper.h"

#include <comms-infras/nifagt_internal.h>

#include <panctrl.h>

#include <btextnotifierspartner.h>

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#include "panprovisioninfo.h" 

#include "panmessages.h"

#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

using namespace PanAgent;

using namespace Messages;

extern "C" EXPORT_C CNifAgentFactory* NewAgentFactoryL()

/**

Pan agent factory

*/

	{	

	return new(ELeave) CPanAgentFactory();

	}

//

// PAN agent factory

//

void CPanAgentFactory::InstallL() 

/**

 * Perform any agent factory initialisation

 */

	{

	LOG_FUNC

	}

CNifAgentBase* CPanAgentFactory::NewAgentL(const TDesC& /*aName*/)

/**

 * Create a new PAN agent

 */

	{

	LOG_FUNC

	return CPanAgent::NewL();

	}

TInt CPanAgentFactory::Info(TNifAgentInfo& aInfo, TInt /*aIndex*/) const

/**

 * Retrieve information about this agent

 * @param aInfo 

 * @param aIndex

 */

	{

	LOG_FUNC

	aInfo.iName = KPanAgentName;

	aInfo.iVersion = TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber);

	return KErrNone;

	}

//

// PAN agent

//

CPanAgent* CPanAgent::NewL()

/**

Return a newly constuct PAN agent

*/

	{

	LOG_STATIC_FUNC

	CPanAgent* self = new(ELeave) CPanAgent();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

CPanAgent::CPanAgent()

/**

Do nothing

*/

	{

	CONNECT_LOGGER

	LOG_FUNC

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    NM_LOG_NODE_CREATE(KPanAgtSubTag, CPanAgent);

#endif

	}

void CPanAgent::ConstructL()

/**

*/

	{

	LOG_FUNC

	CAgentBase::ConstructL();

	iDeviceSelector = new (ELeave) CPanRemoteDeviceSelector(*this, *iDatabase);

	iInitiateDisconnectCallback = new (ELeave) CAsyncCallBack(KPanAgtAoPriority);

	TCallBack initiateDisconnectCallback(InitiateDisconnectCb, this);

	iInitiateDisconnectCallback->Set(initiateDisconnectCallback);

	// Create local SDP helper instance.

	iPanLocalSdpRegistrar = CPanHelperLocalSdpRegistrar::NewL();

	iState = CPanAgtStateUninitialised::NewL(*this);

	iShutdownState = CPanAgtStateShutdown::NewL(*this);

	//If CPanCoexistenceConnectionController::NewL leaves, PAN still can be started as usual

	TRAP_IGNORE(iPanCoexistenceConnectionController = CPanCoexistenceConnectionController::NewL(*this));

	__ASSERT_DEBUG(iPanCoexistenceConnectionController, PanAgentPanic(ECreatePanCoexistenceConnectionControllerFailed));

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	// Register with comms transport to be able to receive our

	// custom PAN/BNEP messages

	TPanMessage::RegisterL();

#endif

	}

CPanAgent::~CPanAgent()

/**

Tidy up after ourselves

*/

	{

	LOG_FUNC

	__ASSERT_DEBUG(Devices().Count()==0, PanAgentPanic(EPanAgentDeletedWithDevicesStillAttached));

	delete iPanLocalSdpRegistrar;

	iRemoteDevices.ResetAndDestroy();

	if (iShutdownState != iState)

		{	

		// something strange happened here, shutdown state not the last used state

		__ASSERT_DEBUG(EFalse, PanAgentPanic(EShutdownStateNotLastState));

		delete iShutdownState;

		iShutdownState = NULL;

		}

	delete iState;

	iState = NULL;

	if(iDeviceSelector)

		{

		iDeviceSelector->Cancel();

		delete iDeviceSelector;

		iDeviceSelector = NULL;

		}

	if(iPanCoexistenceConnectionController)

		{

		delete iPanCoexistenceConnectionController;

		iPanCoexistenceConnectionController = NULL;

		}

	if(iIncomingConnectionListener)	// if we haven't deleted it already...

		{

		// make sure we stopped it

		__ASSERT_DEBUG(!(iIncomingConnectionListener->IsActive()), PanAgentPanic(EIncomingConnectionListenerStillActiveAtShutdown));

		iIncomingConnectionListener->Cancel();	// recover in release builds

		delete iIncomingConnectionListener;

		iIncomingConnectionListener = NULL;	

		}

	iInitiateDisconnectCallback->Cancel();

	delete iInitiateDisconnectCallback;

	iInitiateDisconnectCallback = NULL;

	delete iDeviceSelector;

	iDeviceSelector = NULL;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	// De-register with the comms transport

	TPanMessage::DeRegister();

    NM_LOG_NODE_DESTROY(KPanAgtSubTag, CPanAgent);

#endif

	CLOSE_LOGGER

	}

void CPanAgent::Connect(TAgentConnectType aType)

/**

Start the connection in an appropriate mode, depending on the settings in commdb

*/

	{

	LOG_FUNC

	LOG1(_L("CPanAgent::Connect(TAgentConnectType[%d])"), aType);

	//The IAP must be incoming if we get a reconnect

	if(aType==EAgentStartDialIn || aType==EAgentReconnect)

		{

		SetSuppressOutgoing();

		}

	iError = KErrNone; // make sure iError is reset before entering ConnectComplete

	iState->Connect();

	}

void CPanAgent::Connect(TAgentConnectType aType, CStoreableOverrideSettings* aOverrideSettings)

/**

Pass the override settings to base class, and perform a normal start

*/

	{

	LOG_FUNC

	LOG1(_L("CPanAgent::Connect(TAgentConnectType[%d] + CStoreableOverrideSettings)"), aType);

	TRAPD(err, SetOverridesL(aOverrideSettings));

	if(err) // if we can't store the overrides, then tell nifman and abort the connect

		{

		iError = err;

		iState->Connect();

		return;

		}

	Connect(aType);

	}

void CPanAgent::CancelConnect()

/**

Cancel the ServiceStarted callback - this will prevent the agent starting

*/

	{

	LOG_FUNC

	iState->CancelConnect();

	}

void CPanAgent::ServiceStarted()

/**

@note We can't handle any error conditions here, as nifman doesn't allow us to signal them until

we call ConnectComplete

*/

	{

	LOG_FUNC

	__ASSERT_ALWAYS(iNotify, PanAgentPanic(ENullNifmanNotifyPointer));

	LOG1(_L("CPanAgent: Service started with error %d"), iError);

	iNotify->ServiceStarted(); // trigger loading of nif and packet driver

	}

void CPanAgent::ConnectComplete()

/**

Get the BNEP control interface handle, and create the initial state

*/

	{

	LOG_FUNC

	__ASSERT_ALWAYS(iNotify, PanAgentPanic(ENullNifmanNotifyPointer));

	LOG1(_L("CPanAgent: entered ConnectComplete with error %d"), iError);

	if(!iError) // if everything's OK, then get the handle to the BNEP control interface

		{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        CPanProvisionInfo* provisionInfo=NULL; 

		iError = iNotify->Notification((TAgentToNifEventType)EPanAgentToNifGetPanProvisionInfo, static_cast<TAny*>(&provisionInfo));

		// If this assert fails check your commdb. It probably means that a non-399 commdb

		// has been imported and is using the basic Ethernet MCPR rather than the Pan

		// Ethernet MCPR

    	__ASSERT_ALWAYS(provisionInfo && provisionInfo->BnepConnectionMgr() != Messages::TNodeId::NullId(), PanAgentPanic(ENullBnepConnectionManager));

    	iBnepConnectionManager = provisionInfo->BnepConnectionMgr();

#else

// !SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

		// Get the handle to the nif's connection manager

		LOG(_L("CPanAgent: Getting handle to BNEP control interface..."));

		TBnepConnectionManager bnepConnectionManager;

		iError = iNotify->Notification((TAgentToNifEventType)EPanAgentToNifGetConnectionManager, static_cast<TAny*>(&bnepConnectionManager));

		if(iError == KErrNone)

			{

			iBnepConnectionManager = bnepConnectionManager.iBnepConnectionManager;

			__ASSERT_ALWAYS(iBnepConnectionManager, PanAgentPanic(ENullBnepConnectionManager));

			}

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

		}

	if (iError == KErrNone)

		{

		LOG(_L("CPanAgent: ...got handle successfully"));

		delete iState;

		iState = NULL;

		CPanAgtStateBase* initialState = NULL;

		TRAP(iError, initialState = CPanAgentStateInitialising::NewL(*this));

		if(!iError)

			{

			SetState(*initialState); // this may set iError if there is a problem during initialising		

			}

		}

	if(iError)

		{

		iNotify->AgentProgress(EPanAgtIdle, iError);

		}

	else

		{

		iNifmanConnected = ETrue;

		iNotify->AgentProgress(EPanAgtConnected, KErrNone);

		}

	LOG1(_L("CPanAgent: calling nifman ConnectComplete with error %d)"), iError);

	iNotify->ConnectComplete(iError);

	}

void CPanAgent::Reconnect()

/**

Reset state and asynchronously send reconnect complete back, if 

the IAP is incoming

*/

	{

	LOG_FUNC

	if(AllowIncoming())

		{

		delete iState;

		iState = NULL;

		CPanAgtStateBase* reconState = NULL;

		TRAP(iError, reconState= CPanAgtStateReconnect::NewL(*this));

		if(!iError)

			{

			SetState(*reconState);

			}

		}

	}

void CPanAgent::ReconnectComplete(TInt aErr)

	{

	LOG_FUNC

	iNotify->ReconnectComplete(aErr);

	}

void CPanAgent::CancelReconnect()

/**

*/

	{

	LOG_FUNC

	iState->CancelReconnect();

	}

void CPanAgent::InitiateDisconnect()

/**

Perform an agent initiated disconnect

@note Any code in the agent that wants to trigger a disconnect should call RequestDisconnect(),

which will call this method via an async callback.

@note This call will loop back into the agent because nifman will call the Disconnect() method itself.

*/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iNifmanConnected, PanAgentPanic(EAttemptToDisconnectBeforeConnectComplete));

	LOG1(_L("CPanAgent: InitiateDisconnect with error %d"), iError);

	iNotify->AgentProgress(EPanAgtDisconnecting, iError);

	iNotify->AgentEvent(EAgentOriginatedConnectionCommand, EAgentConnectionCommandStop, TPckg<TInt>(KErrDisconnected));

	}

void CPanAgent::Disconnect(TInt aReason)

/**

Disconnect called from nifman (this can be triggered by the idle timers, the client, or us 

requesting a disconnect using RequestDisconnect()).

This method will cause us to go to the shutdown state in the role state machine, which will

shut everything else down (ie. the remote device state machines).

@note This is the one case where a state transition can occur that is not triggered by a state

itself (because two of the three reasons for this method being called are events external to 

PAN agent, and those events turn up here first, and are not passed to a state; instead they 

trigger the state transition directly)

*/

	{

	LOG_FUNC

	LOG1(_L("CPanAgent: Disconnect with error %d"), aReason);

	iError = aReason;

	// now make shutdown the active state

	delete iState; // we have to do this now, otherwise we lose the pointer

	iState = NULL; // to prevent any mistakes being made...

	SetState(*iShutdownState); // shutdown is complete when ShutdownComplete() is called by the shutdown state	

	}

void CPanAgent::FullShutdownComplete()

/**

Once all devices have reported to the shutdown state that they are disconnected, this method

is called and the agent can disconnect

*/

	{

	LOG_FUNC

	LOG(_L("CPanAgent: Shutdown complete, signalling nifman with DisconnectComplete()"));

	// then tell nifman we've disconnected

	iNotify->AgentProgress(EPanAgtDisconnected, KErrNone);

	iNifmanConnected = EFalse;

	iNotify->DisconnectComplete();

	}

TInt CPanAgent::InitiateDisconnectCb(TAny* aThisPtr)

/**

Initiate disconnect callback static method

*/

	{

	LOG_STATIC_FUNC

	__ASSERT_DEBUG(aThisPtr, PanAgentPanic(ENullTAnyPointer));

	CPanAgent* self = static_cast<CPanAgent*>(aThisPtr);

	self->InitiateDisconnect();

	return KErrNone;

	}

void CPanAgent::Info(TNifAgentInfo& aInfo) const

/**

 * Information about this Agent

 *

 * @param aInfo on return contains information about the agent

 */

	{

	LOG_FUNC

	aInfo.iName = KPanAgentName;

	aInfo.iName.AppendFormat(_L("-AgentFactory[0x%08x]"), this);

	aInfo.iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

TInt CPanAgent::Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption)

/**

Various agent specific options

*/

	{

	LOG_FUNC

	if(aOptionLevel==KCOLAgent)

		{

		TBool listUplinkAccessDev = EFalse;

		switch(aOptionName)

			{

			case KCOGetAgentEMIPtr:	// agent extended management interface getter

				{

				if(aOption.Length()!=sizeof(MNifAgentExtendedManagementInterface*))

					{

					return KErrArgument;

					}

				aOption = TPckg<MNifAgentExtendedManagementInterface*>(this);

				return KErrNone;

				}

			case KCOAgentNotifyClientAttach:

				{

				TRAPD(err, SetupOutgoingConnectionsL()); //<@note This ignores the value of the iSuppressOutgoing flag and triggers the outgoing connections directly

														 // as the outgoing connection suppression is only intended to be used when the agent is first told to Connect()

														 // and not when the 2nd and subsequent clients attach to this connection

				return err;

				}

			case KCOAgentPanConnectDevice:

				{

				if(aOption.Length() != KBTDevAddrSize)

					{

					return KErrArgument;

					}

				TBTDevAddr remoteDeviceAddress(aOption);

				TRAPD(err, CreateNewConnectionForOutgoingL(remoteDeviceAddress));

				return err;

				}

			case KCOAgentPanDisconnectDevice:

				{

				if(aOption.Length() != KBTDevAddrSize)

					{

					return KErrArgument;

					}

				TBTDevAddr remoteDeviceAddress(aOption);

				CPanRemoteDeviceStateMachine* remoteDevice = FindRemoteDeviceByAddress(remoteDeviceAddress);

				if(remoteDevice)

					{

					remoteDevice->Disconnect();

					}

				else

					{

					return KErrNotFound;

					}

				return KErrNone;

				}

			case KCOAgentPanEnumerateUplinkAccessDevices: 

				{

				//set the listing uplink access devices boolean to ETrue

				listUplinkAccessDev = ETrue;

				//the following code will branch based on the value of listUplinkAccessDev

				//fall through

				}

			case KCOAgentPanEnumerateDevices:

				{

				// Because the array passed to us here may be smaller than the number of active links

				// at this point, we shall return as much as possible in the array.

				// Also if the array has enough space for more addresses than we currently have, the

				// descriptor size will be changed to reflect reality.