// 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 <bluetooth/logger.h>

#include <comms-infras/eintsock.h>

#include "CBnepBridge.h"

#include "CBnepChannelController.h"

#include "CBnepLink.h"

#include "RBnepSetupConnectionRequestControl.h"

#include "RBnepSetupConnectionResponseControl.h"

#include "bneputils.h"

#include "RBnepFilterNetTypeSetRequestControl.h"

#include "RBnepFilterNetTypeResponseControl.h"

#include "RBnepFilterMultiAddrSetRequestControl.h"

#include "RBnepFilterMultiAddrResponseControl.h"

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

#include "panmessages.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

/**

Implement cleanup for an RBnepControl object allocated on the heap.

*/

void CleanupControl(TAny* aControl)

    {

    LOG_STATIC_FUNC

    RBnepControl* control = static_cast<RBnepControl*>(aControl);

    control->Free();

    delete control;

    }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

CBnepChannelController::CBnepChannelController (const TNodeId& aNotify, CPacketDriverOwner& aPktDrvOwner)

    : iPanConnectionNotify(aNotify), iPktDrvOwner(aPktDrvOwner)

    {

    NM_LOG_NODE_CREATE(KBnepSubTag, CBnepChannelController);

    CONNECT_LOGGER

    LOG_FUNC

    iPktDrvOwner.Open();

    }

#else

// !SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

CBnepChannelController::CBnepChannelController (MPanConnectionNotify& aNotify)

        :iNotify(aNotify)

    {

    LOG_FUNC

    }

#endif

// SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

CBnepChannelController::~CBnepChannelController()

    {

    /**

       Close all objects that we're reponsible for - including the socket.

       @internalComponent

    */

    LOG_FUNC

    if(iLink)

        {

        delete iLink;

        //  iLink must be reset to zero after deletion to prevent a later panic.

        iLink = NULL;

        }

    iProceedCallBack->Cancel();

    delete iProceedCallBack;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    NM_LOG_NODE_DESTROY(KBnepSubTag, CBnepChannelController);

    CLOSE_LOGGER

    iPktDrvOwner.Close();

#endif

    }

void CBnepChannelController::BnepRoleRequestFromLocalDevice (TBluetoothPanRole aRequestedLocalRole, TBluetoothPanRole aRequestedRemoteRole)

    {

    /**

       Call from the agent to request that we set a certain role.

       @internalComponent

    */

    LOG_FUNC

    iLink->SuspendDataTransfer();

	TRAPD(err, CreateAndQueueConnectionSetupRequestL(aRequestedLocalRole, aRequestedRemoteRole));

	if(!err)

		{

    	iLink->Proceed();

		}

	else

		{

		iLink->ResumeDataTransfer();

		}

    }

void CBnepChannelController::SetUplinkAccessAllowedForBnepLink(TBool aAllowed)

	{

	iLink->SetUplinkAccessAllowedForBnepLink(aAllowed);

	}

/**

Response to a remote request for a given set of roles -- generate control

packet and pass it back to the remote device.

@internalComponent

*/

void CBnepChannelController::BnepRoleResponseFromLocalDevice (TBnepSetupConnectionResponseMessage aRoleResponseCode)

    {

	// This may fail if it cannot allocate the response.  However,

	// we will just continue and do the same as if it had succeeded

	// as we won't get another prompt to continue.  The remote may

	// resend its ConnectionSetupRequest when we don't respond, or

	// may disconnect the link.

	TRAP_IGNORE(CreateAndQueueConnectionSetupResponseL(aRoleResponseCode));

    // All control processing has been suspended while awaiting this event, 

    // so we can now free things up again.

    SetAwaitingResponse(EFalse);

    iLink->ResumeDataTransfer();	// enable the link for data transfer	

    if(EOperationSuccessful == aRoleResponseCode)

        {

        //In case this is the first negotiation, we only want to trigger LinkLayerUp if the 

	    //negotiation is successful

        iLink->RemoteDeviceReady();

        }

	//If iProceedCallBack is already active then BNEP must be processing the next command inside 

	//the same frame. We don't have to don't anything here. The callback will complete when all the

	//commands are processed.

    if(!iProceedCallBack->IsActive())

    	{

    	__ASSERT_DEBUG(!iProceedCallBack->IsAdded(), BnepUtils::Panic(Bnep::ECallBackAlreadyAdded));

		CActiveScheduler::Add(iProceedCallBack);

	    iProceedCallBack->CallBack();

    	}

    }

TInt CBnepChannelController::ProceedCb(TAny* aPtr)

	{

	static_cast<CBnepChannelController*>(aPtr)->Proceed();

	return KErrNone;

	}

void CBnepChannelController::Proceed()

	{

	iProceedCallBack->Deque();

    // Carry on processing any outstanding controls and data transfers.

    iLink->Proceed();

    }

/**

   Close this channel. This has the effect of deleting the coupled CBnepLink.

   @internalComponent

*/

void CBnepChannelController::Close ()

    {

    LOG_FUNC

    delete this;

    }

/**

   Create the channel controller and the link object.

   Ownership of all these objects is a little strange -- the channel controller

   owns the underlying link, and the channel controller itself is owned by the

   agent (in another dll...).  Destruction paths can therefore look a little

   confusing.

   @internalComponent

*/

void CBnepChannelController::ConstructL (CBnepBridge& aBridge, RInternalSocket& aConnectedSocket)

    {

    LOG_FUNC

    iLink = CBnepLink::NewL(aBridge, aConnectedSocket, *this);

    iProceedCallBack = new (ELeave) CAsyncCallBack(KBnepProceedCallBackPriority);

    TCallBack proceedCb(ProceedCb, this);

    iProceedCallBack->Set(proceedCb);

    //Remove the callback from active scheduler whenever it is not used because it is

    //used only in role request and has a high priority.

    iProceedCallBack->Deque();

    }

/**

   Having received a SetupConnectionRequest from a remote device, the controller 

   must hand off the request to the agent. This may be asynchronous, in which case

   the method returns immediately, having suspended further control processing 

   until the agent responds. However, the agent may call back into the controller 

   synchronously. This has implications for how controls are processed by the link.

   @internalComponent

*/

void CBnepChannelController::Handle (RBnepSetupConnectionRequestControl* aSetupRequest)

    {

    LOG_FUNC

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

    if(aSetupRequest)

        {

        TUUID localRole;

        TUUID remoteRole;

        TInt err1 = aSetupRequest->LocalRole(localRole);

        TInt err2 = aSetupRequest->RemoteRole(remoteRole);

        // The control object must be freed and deleted now, before the request is 

        // passed out, to ensure that the controller is re-entrant and doesn't leak memory.

        aSetupRequest->Free();

        delete aSetupRequest;

        if(!err1 && !err2)

            {

            // Suspend further link processing for the time being.

            SetAwaitingResponse(ETrue);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

            TPanMessage::TRoleRequestFromRemoteDevice msg(localRole, remoteRole);

            RClientInterface::OpenPostMessageClose(Id(),iPanConnectionNotify,msg);

#else

            iNotify.BnepRoleRequestFromRemoteDevice(localRole, remoteRole);

#endif

            }

        else

            {

			// The UUIDSize is not within spec, so we need to tell the remote end.

			// This may leave if we fail to allocate the new response.  Unfortunately

			// there's not a lot we can do in that circumstance.  Just drop our response

			// and wait for the remote to timeout.

			TRAP_IGNORE(CreateAndQueueConnectionSetupResponseL(EInvalidServiceUuidSize));

            }

        }

    }

/**

   The remote device has sent a response to our Setup request. If it has 

   been successful we can resume data transfer operations on the link. 

   The agent is notified of the response.

   @param aSetupResponse A control containing the remote end's response to our 

   request to set up a connection.

   @internalComponent

*/

void CBnepChannelController::Handle (RBnepSetupConnectionResponseControl* aSetupResponse)

    {

    LOG_FUNC

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

    if(aSetupResponse)

        {

        TBnepSetupConnectionResponseMessage responseCode = EOperationSuccessful;

        TRAPD(err,aSetupResponse->ConnectionSetupResponseL(responseCode));

		if(!err)

			{

			iLink->ResumeDataTransfer();

	        if(EOperationSuccessful == responseCode)

	            {

	            //In case this is the first negotiation, we only want to trigger LinkLayerUp if the 

	            //negotiation is successful

	            iLink->RemoteDeviceReady();

	            }

	        // The control object must be freed and deleted now, before the request is 

	        // passed out, to ensure that the controller is re-entrant and doesn't leak memory.            

	        aSetupResponse->Free();

	        delete aSetupResponse;        

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

            TPanMessage::TRoleResponseFromRemoteDevice msg(responseCode);

            RClientInterface::OpenPostMessageClose(Id(),iPanConnectionNotify,msg);	        

#else

	        iNotify.BnepRoleResponseFromRemoteDevice(responseCode);

#endif

			}

		else

			{

			// They sent us bobbins, just drop it.

	        aSetupResponse->Free();

	        delete aSetupResponse; 

			}

        }

    }

/**

   Handle an attempt, by a remote device, to set network packet type filters.

   @param aFilterNetTypeSetRequest A control containing a network packet type 

   filter set message.

   @internalComponent

*/

void CBnepChannelController::Handle (RBnepFilterNetTypeSetRequestControl* aFilterNetTypeSetRequest)

    {

    LOG_FUNC

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

    if(aFilterNetTypeSetRequest)

        {

        TFilterNetTypeResponse response;        

        // Specification requires that we check the validity of the filter request 

        // before it is implementeted in BNEP.                                     

        TUint16 typeListSize ;

        TInt err1 = aFilterNetTypeSetRequest->NetworkProtocolTypeListLength(typeListSize);

        if(!err1)

            {

            LOG1(_L8("NetworkProtocolTypeListLength = %d"),typeListSize); 

            if((2*KMaxNetTypeFilters*KSizeOfNetType) < typeListSize)

                {

                response = EFilterNetTypeTooManyFilters;

                }

            else

                {

                CNetTypeFilterTable* netTypeFilterTable = new CNetTypeFilterTable;

                if(netTypeFilterTable)

                    {

                    TUint index = 0;

                    do

                        {

                        TUint16 startValue;

                        TUint16 endValue;

                        err1 = aFilterNetTypeSetRequest->NetworkProtocolTypeRange(startValue, endValue, index);

                        index++;

                        LOG2(_L8("Net type filter request: startValue: %d , endValue: %d"),startValue, endValue);

                        if( KErrGeneral == err1 )

                            {

                            // This one is because the advertised length doesn't match what's 

                            // actually in the packet.

                            response = EFilterNetTypeUnsupportedRequest;

                            break;

                            }

                        if( KErrArgument == err1 )

                            {

                            // This one means they've somehow got their start and end 

                            // addresses in the wrong order.

                            response = EFilterNetTypeInvalidNetworkingProtocolTypeRange;

                            break;

                            }

                        if(KErrNotFound != err1)

                            {

                            TInt err2 = netTypeFilterTable->Insert(startValue, endValue);

                            if( KErrArgument == err2 )

                                {

                                // This one means they've somehow got their start and end 

                                // addresses in the wrong order, and we didn't catch it earlier.

                                response = EFilterNetTypeInvalidNetworkingProtocolTypeRange;

                                break;

                                }  

                            if( KErrTooBig == err2 )

                                {

                                // This one means that they've asked for more filters than 

                                // we currently support.

                                response = EFilterNetTypeTooManyFilters;

                                break;

                                }  

                            response = EFilterNetTypeOperationSuccessful;  

                            }

                        else

                            {

                            netTypeFilterTable->Reset(); // This is going to be an empty table

                            response = EFilterNetTypeOperationSuccessful; // This is supported

                            err1 = KErrEof; // Nothing more to be done

                            }

                        }while( KErrEof != err1 );

                    if(EFilterNetTypeOperationSuccessful == response)

                        {

                        // We can now adopt the new filter table.

                        // The link will own it and be responsible for it's deletion.

                        iLink->Install(netTypeFilterTable);

                        }

                    else

                        {

                        // That request failed for some reason, so drop the new table.

                        delete netTypeFilterTable;

                        }

                    }

                else

                    {

                    // If we get here, then we have failed to construct a CNetTypeFilterTable. 

                    // There is nothing in the protocol that allows us to pass back a generic 

                    // "Request Unsuccessful" message, so the nearest we could come up with was 

                    // "Too Many Filters", which is a bit more truthful that "Unsupported Request".

                    response = EFilterNetTypeTooManyFilters;

                    }

                }

            }

        else

            {

            response = EFilterNetTypeUnsupportedRequest;

            }

        // The control object must be freed and deleted now, before the response is 

        // generated, to ensure that the controller is re-entrant and doesn't leak memory.

        aFilterNetTypeSetRequest->Free();

        delete aFilterNetTypeSetRequest;

		// This may leave if we fail to allocate the new response.  Unfortunately

		// there's not a lot we can do in that circumstance.  Just drop our response

		// and wait for the remote to timeout.

		TRAP_IGNORE(CreateAndQueueFilterNetTypeResponseL(response));

        }

    }

/**

   This overloaded method is a placeholder for the code that will handle 

   responses from the remote end after BNEP hass emitted a Filter Net Type 

   Request.This version of BNEP does not emit these requests.

   @internalComponent

*/

void CBnepChannelController::Handle (RBnepFilterNetTypeResponseControl* aFilterNetTypeResponse)

    {

    LOG_FUNC

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

    // We don't do anything with this yet

    if(aFilterNetTypeResponse)

        {

        aFilterNetTypeResponse->Free();

        delete aFilterNetTypeResponse;

        }

    }

/**

   Handle an attempt by a remote device to set multicast adddress filters

   @internalComponent

*/

void CBnepChannelController::Handle (RBnepFilterMultiAddrSetRequestControl* aFilterMultiAddrSetRequest)

    {

    LOG_FUNC

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

    if(aFilterMultiAddrSetRequest)  

        {

        TInt err1;

        TBnepBTDevAddr startAddr;

        TBnepBTDevAddr endAddr;

        TFilterMultiAddrResponse response;

        // Specification requires that we check the validity of the filter request 

        // before it is implementeted in BNEP.                                     

        TUint16 typeListSize = aFilterMultiAddrSetRequest->MulticastAddressListLength();

        LOG1(_L8("MulticastAddressListLength = %d"),typeListSize); 

        if((2*KMaxMultiAddrFilters*KSizeOfMultiAddr) < typeListSize)

            {

            LOG(_L8("Too many filters"));

            response = EFilterMultiAddrTooManyFilters;

            }

        else

            {

            CMultiAddrFilterTable* multiAddrFilterTable = new CMultiAddrFilterTable;

            if(multiAddrFilterTable)

                {

                TUint index = 0;

                do

                    {

                    err1 = aFilterMultiAddrSetRequest->MultiAddrRange(startAddr, endAddr, index);

                    if(KErrArgument == err1)

                        {

                        response = EFilterMultiAddrUnsupportedRequest;

                        break; // Stop processing this request

                        }

                    if(KErrNotFound != err1)

                        {

                        TInt err2 = multiAddrFilterTable->Insert(startAddr, endAddr);

                        if( KErrArgument == err2 )

                            {

                            response = EFilterMultiAddrUnsupportedRequest;

                            break; // Stop processing this request

                            }  

                        if( KErrTooBig == err2 )

                            {

                            response = EFilterMultiAddrTooManyFilters;

                            break; // Stop processing this request

                            }  

                        response = EFilterMultiAddrOperationSuccessful; // Must be good if we got here.

                        ++index;

                        }

                    else

                        {

                        multiAddrFilterTable->Reset(); // This is going to be an empty table

                        response = EFilterMultiAddrOperationSuccessful; // This is supported

                        err1 = KErrEof; // Nothing more to be done

                        }

                    } while( KErrEof != err1 );

                if(EFilterMultiAddrOperationSuccessful == response)

                    {

                    // We can adopt the new filter table.

                    // The link will own it and be responsible for it's deletion.

                    iLink->Install(multiAddrFilterTable);

                    }

                else

                    {

                    // That request failed for some reason, so drop the new table unused.

                    delete multiAddrFilterTable;

                    }

                }

            else

                {

                // If we get here, then we have failed to construct a CMultiAddrFilterTable. 

                // There is nothing in the protocol that allows us to pass back a generic 

                //  "Request Unsuccessful" message, so the nearest we could come up with was 

                //  "Too Many Filters", which is a bit more truthful that "Unsupported Request".

                response = EFilterMultiAddrTooManyFilters;

                }

            }

        // The control object must be freed and deleted now, before the request is 

        // honoured, to ensure that the controller is re-entrant and doesn't leak memory.

        aFilterMultiAddrSetRequest->Free();

        delete aFilterMultiAddrSetRequest;