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

 @internalComponent

*/

#include <e32std.h>

#include <bluetooth/logger.h>

#include <bttypes.h>

#include <comms-infras/eintsock.h>

#include <elements/nm_interfaces.h>

#include "CBnepBridge.h"

#include "CBnepChannelController.h"

#include "RBnepFrame.h"

#include "bneputils.h"

#include "CBnepLocalDevice.h"

#include "CBnepLink.h"

#include <networking/pktdrv.h>

#include "pancommon.h"

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#include <elements/nm_node.h>

#include <comms-infras/ss_common.h>

#include "panmessages.h"

#include <bt_sock.h>

#include <bttypes.h>

using namespace ESock;

using namespace Messages;

#ifdef ESOCK_EXTLOG_ACTIVE

_LIT8(KBnepSubTag, "bnep");

#endif

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_BNEP);

#endif

#ifdef _DEBUG

PANICCATEGORY("panbnep");

#endif

// Class CBnepBridge 

/**

   Create the bridge and attach the local device to it.

*/

CBnepBridge::CBnepBridge (MPanDevice& aLocalDevice) : iDataTransferred(KMaxPanConnections)

    {

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    NM_LOG_NODE_CREATE(KBnepSubTag, CBnepBridge);

#endif

    CONNECT_LOGGER

    LOG_FUNC

    iLinks[KBnepLocalDeviceArrayId] = &aLocalDevice; 

    iLinkCount = 1;

    LOG2(_L8("CBnepBridge::iLinks[%d] = 0x%08x"),KBnepLocalDeviceArrayId,iLinks[KBnepLocalDeviceArrayId]);

    }

/**

   Destroy the bridge.  Does not delete the devices as they are not owned by

   the bridge. The links will be deleted when the CBnepChannelControllers are deleted.

*/

CBnepBridge::~CBnepBridge()

    {

    LOG_STATIC_FUNC

    /**

       Destroy the bridge.  Does not delete the devices as they are not owned by

       the bridge. The links will be deleted when the CBnepChannelControllers are deleted.

       @internalComponent

    */

    delete iDataCounterTimer;

    if (iBnepPacketNotifier)

    	{

    	iBnepPacketNotifier->MbpnbRelease();

    	iBnepPacketNotifier = NULL;

    	}

    iLib.Close();

    iDataTransferred.Close();

    LOG1(_L8("CBnepBridge holds %d links on destruction - Invalidating links..."),iLinkCount);

    for (TUint index = 0; index < KMaxPanConnections; ++index)

        {

        if((index != KBnepLocalDeviceArrayId) && (iLinks[index]))

            {

			// Invalidate the link as it is no longer bound to a bridge.

            static_cast<CBnepLink*>(iLinks[index])->Invalidate();

            }

        }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    // Deregister custom messages with the comms transport

    TPanMessage::DeRegister();

    NM_LOG_NODE_DESTROY(KBnepSubTag, CBnepBridge);

	delete iPanLinkControl;

#endif

	CLOSE_LOGGER

    }

/**

   Add a new device to the bridge

   @return KErrOverflow The maximum number of supported devices are already

   in the network.

*/

TInt CBnepBridge::AttachDevice (MPanDevice& aDevice)

    {

    LOG_FUNC

    TUint spareSlot;

    TInt err = GetVacantSlot(spareSlot);

    if(KErrNone == err)

        {

        iLinks[spareSlot] = &aDevice;

        iLinkCount++;

        LOG2(_L8("CBnepBridge attaching iLinks[%d] = 0x%08x"),spareSlot,iLinks[spareSlot]);

        LOG1(_L8("CBnepBridge holds %d links"),iLinkCount);

        if (iBnepPacketNotifier) 

        	{

        	TBnepBytesTransferred counter;

        	counter.iBytesReceived=0;

        	counter.iBytesSent=0;

        	counter.iBTDevAddr=aDevice.iAddr;

	      	__ASSERT_ALWAYS(iDataTransferred.Append(counter)==KErrNone,BnepUtils::Panic(Bnep::EAppendFailed)); // Shouldn't fail as the granularity of the array is the maximum number of devices available.

 	      	TInt pos = iDataTransferred.Find(counter);

			__ASSERT_ALWAYS(pos != KErrNotFound, BnepUtils::Panic(Bnep::EAppendFailed));

			TBnepBytesTransferred* countPtr = &iDataTransferred[pos];

 			aDevice.SetOwnerCountPtr(countPtr);

	      	iBnepPacketNotifier->MbpnDeviceAdded(aDevice.iAddr);

	      	__ASSERT_ALWAYS(iDataCounterTimer,BnepUtils::Panic(Bnep::ENullPointer));

    	    if (!iDataCounterTimer->IsActive())

    			{

    				iIdleCount=0;

    				iDataCounterTimer->Start(KBnepPacketNotifyInterval,KBnepPacketNotifyInterval,TCallBack(DataCounterCallBack,this)); // Start the timer if it's not already started

    			}

        	}

        }

    return err; 

    }

/**

   Get the default (local) address for this bridge (i.e. address of it's local device).

*/

const TBTDevAddr& CBnepBridge::DefaultAddress () const

    {

    LOG_FUNC

    __ASSERT_ALWAYS(iLinks[KBnepLocalDeviceArrayId],BnepUtils::Panic(Bnep::ENullPointer));

    LOG_BT(_L8("CBnepBridge::DefaultAddress: %S"),iLinks[KBnepLocalDeviceArrayId]->iAddr);

    return iLinks[KBnepLocalDeviceArrayId]->iAddr; 

    }

/**

   Notify the bridge of the imminent destruction of a link.. 

   This is normally called by a CBnepLink destructor, to notify the bridge that 

   it is going down. However, it is possible for a CBnepLink instance to exist 

   for a time without being attached to the bridge. This instance is silently managed.

*/

void CBnepBridge::LinkGoingDown (MPanDevice& aDevice)

    {

    LOG_FUNC

    // We may safely ignore the return value here.

    RemoveDevice(aDevice);

    }

void CBnepBridge::RemoteDeviceReady ()

	{

    LOG_FUNC

	// Inform the local device that a remote device is ready

	static_cast<CBnepLocalDevice*> (iLinks[KBnepLocalDeviceArrayId])->RemoteDeviceReady();

	}

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

/**

   Create a new bnep channel as a result of an incoming request

   @param aMessage The message that requested the new channel controller

*/

void CBnepBridge::AttemptNewBnepConnection(const Messages::TNodeId& aSender, const Messages::TSignatureBase& aMessage, TUint16 aActivityId)

    {

    LOG_FUNC

    CBnepChannelController* bnepChannelControl = NULL;

	// 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_DEBUG(iPktDrvOwner);

    // The RInternalSocket pointer in the message is owned by PAN and must

    // not be deleted or used. The internal socket implementation must be

    // transfered to a local RInternalSocket (see CBnepLink)

    const TPanMessage::TCreateChannelController& msg = message_cast<const TPanMessage::TCreateChannelController>(aMessage);

    // msg.iSender in this case should be an instance of the CPanRemoteDeviceStateMachine

    TRAPD(err, bnepChannelControl = CBnepChannelController::NewL(*this, *msg.iSocket, aSender, *iPktDrvOwner));

    if (err != KErrNone)

        {

        // Report failure to create

        TPanMessage::TChannelControllerCreated failMsg(err);

        RClientInterface::OpenPostMessageClose(TNodeCtxId(aActivityId,Id()),aSender,failMsg);

        return;

        }

	// Same timing as pre-399, give the notifier something to call into

    if (iBnepPacketNotifier) 

    	{

    	iBnepPacketNotifier->MbpnSetLinkControl(*iPanLinkControl);

    	}

    // Send the ack on behalf of the new channel controller

    TPanMessage::TChannelControllerCreated successMsg(KErrNone);

    RClientInterface::OpenPostMessageClose(TNodeCtxId(aActivityId,bnepChannelControl->Id()),aSender,successMsg);

    }

#else

// !SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

/**

   Create a new bnep channel as a result of an incoming request

   @param aConnectedSocket A connected L2CAP socket, ready for BNEP signalling

   @param aNotify Object to inform of events

*/

MBnepChannelControl& CBnepBridge::NewBnepConnectionL(RInternalSocket& aConnectedSocket, MPanConnectionNotify& aNotify)

    {

    LOG_FUNC

    MBnepChannelControl& bnepChannelControl = *CBnepChannelController::NewL(*this, aConnectedSocket, aNotify);

    if (iBnepPacketNotifier) 

    	{

    	iBnepPacketNotifier->MbpnSetLinkControl(aNotify.BnepConnectionController());

    	}

    return bnepChannelControl;

    }

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

CBnepBridge* CBnepBridge::NewL (MPanDevice& aLocalDevice)

    {

    LOG_STATIC_FUNC

    CBnepBridge* self = new(ELeave) CBnepBridge(aLocalDevice);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self; 

    }

void CBnepBridge::ConstructL() 

	{

    LOG_FUNC

    _LIT(KBnepPacketNotifier,"bnepPacketNotifier.dll");

    if (iLib.Load(KBnepPacketNotifier)==KErrNone) 

    	{

    	TLibraryFunction func=iLib.Lookup(1);

    	MBnepPacketNotifierBase* notifier;

    	notifier = (MBnepPacketNotifierBase*) (*func)();

    	iBnepPacketNotifier = (MBnepPacketNotifier*) notifier->MbpnbGetInterface(KUidBnepPacketNotifierV1);

    	__ASSERT_DEBUG(iBnepPacketNotifier, BnepUtils::Panic(Bnep::ENullPointer));

    	if (iBnepPacketNotifier) 

    		{

    		iDataCounterTimer=CPeriodic::NewL(CActive::EPriorityStandard);

    		}

 		}

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    // Register with the comms transport so we can receive custom messages

    TPanMessage::RegisterL();

	// Create our own MPanLinkControl implementation

	iPanLinkControl = CPanLinkControl::NewL();

#endif    

	}

TInt CBnepBridge::DataCounterCallBack(TAny* aThis) 

	{

    LOG_STATIC_FUNC

	CBnepBridge* self = static_cast<CBnepBridge*>(aThis);

	self->DataCounterNotify();

	return KErrNone;

	}

void CBnepBridge::DataCounterNotify()

	{

    LOG_FUNC

	TBool dataTransferred=EFalse;

	iBnepPacketNotifier->MbpnBnepDataTransferred(iDataTransferred.Array()); // Notify the number of bytes transferred

	for (TUint dev=0;dev<iDataTransferred.Count();++dev)

		{

		if (iDataTransferred[dev].iBytesSent!=0 || iDataTransferred[dev].iBytesReceived!=0)

			{

			iDataTransferred[dev].iBytesSent=0;

			iDataTransferred[dev].iBytesReceived=0;

			dataTransferred=ETrue;

			}

		} // Work out whether any bytes have been transferred

	if (!dataTransferred)  // If not

		{

		iIdleCount++; // Increase the idle count by 1

		if (iIdleCount >= KBnepPacketNotifySleepTicks) // If the idle count has been hit

			{

			__ASSERT_ALWAYS(iDataCounterTimer,BnepUtils::Panic(Bnep::ENullPointer));

			iDataCounterTimer->Cancel(); // Cancel the timer

			}

		}

	else  // If data has been transferred

		{

		iIdleCount=0; // Reset the idle counter

		}

	}

/**

   Pass a BNEP frame onto the required device(s).

   Possible options are: local device, multicast address, single remote device.

   @return KReadyForMoreData in all cases.

*/

TInt CBnepBridge::Process (RBnepFrame& aFrame, const TBTDevAddr& aSourceIfAddr)

    {  

    LOG_FUNC

    TBool foundDevice = EFalse;

    LOG(_L8("CBnepBridge: Delivering packet:"));

    LOG_BT(_L8("CBnepBridge: Source address: %S"), aFrame.SrcAddr());

    LOG_BT(_L8("CBnepBridge: Destination address: %S"), aFrame.DestAddr());

    TUint link;

    switch (aFrame.DestinationType())

        {

        case RBnepFrame::ELocal:

            LOG(_L8("CBnepBridge: Frame type: RBnepFrame::ELocal"));	

            iLinks[KBnepLocalDeviceArrayId]->Process(aFrame);

            break;

        case RBnepFrame::EMulticast:

            LOG(_L8("CBnepBridge: Frame type: RBnepFrame::EMulticast"));

            LOG_BT(_L8("Source address %S"),aSourceIfAddr);

            for (link = 0; link < KMaxPanConnections; link++)

                {

                LOG1(_L8("iLinks[%d]"),link);

                if ((iLinks[link] != NULL) &&

                    (!(aSourceIfAddr == (iLinks[link]->iAddr))) &&

                    (!(aFrame.SrcAddr() == (iLinks[link]->iAddr))) )

                    {

                    LOG_BT(_L8("Multicasting to %S"), iLinks[link]->Addr());

                    iLinks[link]->Process(aFrame);

                    }

                }

            break;

        case RBnepFrame::ENormal:

            LOG(_L8("CBnepBridge: Frame type: RBnepFrame::ENormal"));

            for (link = 0; link < KMaxPanConnections; link++)

                {

                if (iLinks[link])

                    {

                    MPanDevice* linkDev = iLinks[link];

                    if (linkDev->ForThisDevice(aFrame.DestAddr()))

                        {

                        LOG_BT(_L8("Found match, delivering to %S"), linkDev->Addr());

                        linkDev->Process(aFrame);

                        foundDevice = ETrue;

                        break;

                        }

                    }

                }

            // unicast frame to a MAC address we haven't found.

            // We must be in U role connected to a GN/NAP.

            // In which case this bridge's link count must be EXACTLY 2 

            // - this device and the GN. 

            // Otherwise it is a GN and therefore has no

            //  sensible destination for this frame.

            if(!foundDevice && (2 == iLinkCount) )

                {

                // Never assume thak iLinks[0] is always going to be the local device.

                // iLinks[KLocalDeviceArrayId] is the local device.

                for (link = 0; link < KMaxPanConnections; ++link) 

                    {

                    // skip the local connection

                    if(KBnepLocalDeviceArrayId != link)

                        {

                        if(iLinks[link])

                            {

                            iLinks[link]->Process(aFrame);	

                            }

                        }

                    }

                }

            break;	

        default:	

            // Obviously we shouldn't get here under normal circumstances.

            // In a UDEB build we'll log the event.

            // Otherwise, just drop the frame.

            LOG(_L8("CBnepBridge: Invalid destination type."));

        }

    aFrame.Reset();

   	return (KReadyForMoreData);

    }

void CBnepBridge::DataCountUpdated()

	{

    LOG_FUNC

	__ASSERT_ALWAYS(iDataCounterTimer,BnepUtils::Panic(Bnep::ENullPointer));

	if (!iDataCounterTimer->IsActive()) // If the timer is not active

		{

	    iIdleCount = 0; // Reset the idle counter

 	    iDataCounterTimer->Start(KBnepPacketNotifyInterval,KBnepPacketNotifyInterval,TCallBack(DataCounterCallBack,this)); // Start the timer

 	    }

 	}

/**

	Set a flag to enable a connection retry to occur - this means that Nifman will not be signalled when we disconnect all devices

*/

void CBnepBridge::SetRetryConnect () 

	{

    LOG_FUNC

	iRetryConnect=ETrue;

	}

/**

   Remove a device from the bridge.

*/

void CBnepBridge::RemoveDevice (MPanDevice& aDevice)

    {

    LOG_FUNC

    for (TUint index = 0; index < KMaxPanConnections; ++index)

        {

        if(iLinks[index] == &aDevice)

            {

            iLinks[index] = NULL;

            LOG1(_L8("CBnepBridge removed iLink[%d]"),index);

            iLinkCount--;

            LOG1(_L8("CBnepBridge has %d links"),iLinkCount);

			if (iBnepPacketNotifier) 

        		{

        		for (TUint dataIndex=0; dataIndex < iDataTransferred.Count(); ++dataIndex)

        			{

        			if (iDataTransferred[dataIndex].iBTDevAddr==aDevice.iAddr) 

        				{

        				iDataTransferred.Remove(dataIndex);

        				}

        			}

        		iBnepPacketNotifier->MbpnDeviceRemoved(aDevice.iAddr);

        		}

			// If no more remote devices, tell the local device

        	if (iLinkCount == 1 && !iRetryConnect)

        		{

	            LOG1(_L8("CBnepBridge::RemoveDevice - Only local link remaining [0x%08x]"), iLinks[KBnepLocalDeviceArrayId]);

        		static_cast<CBnepLocalDevice*> (iLinks[KBnepLocalDeviceArrayId])->AllRemoteDevicesDisconnected ();

        		}

            iRetryConnect = EFalse;

            break;

            }

        }

    }

/**

   Forces a disconnect on all links.

*/

void CBnepBridge::StopLinks ()

    {

    LOG_FUNC

    for (TUint index = 0; index < KMaxPanConnections; ++index)

        {

        if((KBnepLocalDeviceArrayId !=index) &&

           (NULL != iLinks[index]))

            {

            iLinks[index]->Stop(); // Stops all pending reads.

            }

        }

    }

/**

   Attempts to find the index of a vacant slot in the bridge device array.

   @param aSlotIndex holds the array index of the vacant slot on success

   @return KErrNone on success

   @return KErrOverflow if there is no vacant slot

*/

TInt CBnepBridge::GetVacantSlot (TUint& aSlotIndex)

    {

    LOG_FUNC

    for(TUint index = 0; index < KMaxPanConnections; ++index)

        {

        if(NULL == iLinks[index])

            {

            aSlotIndex = index;

            return KErrNone;

            }

        }

    return KErrOverflow;

    }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

/**

Entry point from the comms transport

*/

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