// 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 <e32std.h>

#include <bttypes.h>

#include <es_mbuf.h>

#include "RBnepFrame.h"

#include "bneputils.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAN_BNEP);

#endif

const TUint8  KEBit = 0x80;

const TUint16 KQTag = 0x8100;

// 'minTypeValue' from section 4.2.7.1 of the 802.3-2002 specification

// Subtract one, as the constant in the spec is for the first non-length value.

const TUint16 K802_3MaxLength = 1536 - 1;

void doResetControl(TAny* aControl)

    {

    /**

       Reset and destroy an RBnepControl object.

    */

    LOG_STATIC_FUNC

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

    control->Free();

    delete control;

    }

RBnepFrame::RBnepFrame()

        : iCommandQueue(_FOFF(RBnepControl, iLink))

    {

    /**

       Construct and initialise (reset) a BNEP frame.

       @internalComponent

    */

    LOG_FUNC

    Reset(); 

    }

void RBnepFrame::BuildBnepControlFrameL (RMBufChain& aChain)

    {

    /**

       Build a BNEP control frame from the encapsulated data.

       @param aChain The target to build the frame into.

       @internalComponent

    */

    LOG_FUNC

    TUint8 frameType = EBnepControl;

    // There have to be items in the command queue 

    if(iCommandQueue.IsEmpty())

        {

        User::Leave(KErrUnderflow);

        }

    else

        {

        // If the last item is also the first one, there must be

        // one and only one item in the queue.

        // If there is more than one, then the ebit must be set.

        // Note: there is no checking done here that the queue items are

        // small enough to fit into an extension header.

        TUint8 ebit = static_cast<TUint8>(((iCommandQueue.IsLast(iCommandQueue.First())) ? 0 : KEBit));

        frameType |= ebit;

        RBnepControl* buffer = iCommandQueue.First();

        buffer->CopyL(aChain);

        iCommandQueue.Remove(*buffer);

        buffer->Free();

        delete buffer;

        aChain.PrependL(sizeof(TUint8));

        TPckgBuf<TUint8> pkgFrameType(frameType);

        aChain.CopyIn(pkgFrameType,RBnepControl::KControlTypeOffset);

        if(ebit) // We have at least one extension

            {

            TSglQueIter<RBnepControl> iter(iCommandQueue);

            iter.SetToFirst();

            RBnepControl* element;

            while ((element = iter++), element)

                {

                TPckgBuf<TInt8> aLength(static_cast<TInt8>(element->Length()));

                element->PrependL(sizeof(TInt8));

                element->CopyIn(aLength);

                element->PrependL(sizeof(TUint8));

                if(iCommandQueue.IsLast(element))

                    {

                    TPckgBuf<TUint8> extFrameType(static_cast<TUint8>(EBnepExtensionControl));

                    element->CopyIn(extFrameType);

                    }

                else

                    {

                    // The extension bit must be set.

                    TPckgBuf<TUint8> extExtFrameType(static_cast<TUint8>(EBnepExtensionControl | KEBit));

                    element->CopyIn(extExtFrameType);

                    }

                aChain.Append(*element);

                }

            }

        LOG1(_L8("Final Chain length = %d"),aChain.Length());

        Reset();

        }

    }

void RBnepFrame::BuildBnepDataFrameL(RMBufChain& aChain, 

                                     const TBTDevAddr& aLocalAddr, 

                                     const TBTDevAddr& aRemoteAddr,

                                     TBool aFilterEthernetPayload)

    {

    /**

       Build a BNEP data frame from the encapsulated data.

       The method deals with compressing off any unnecessary address data based on

       the parameters supplied.

       @param aChain The target to build the frame into.

       @param aLocalAddr The address of the bridge (local side of BNEP link).

       @param aRemoteAddr The address of the remote end of the BNEP link.

    */

    LOG_FUNC

    // If the command queue has items in it, we need to build extension headers.

    TUint8 frameType;

    TBool sendDest = (aRemoteAddr != iDestAddr);

    TBool sendSrc  = (aLocalAddr  != iSrcAddr);

    TInt headerLength;

    if (sendDest && sendSrc)

        {

        frameType = EBnepGeneralEthernet;

        headerLength = KGeneralEthernetHeaderLength;

        LOG(_L8("frameType = EBnepGeneralEthernet;"));

        LOG1(_L8("headerLength = %d"),headerLength);

        }

    else 

        {

        if (sendSrc)

            {

            frameType = EBnepCompressedEthernetSourceOnly;

            headerLength = KCompressedEthernetSourceOnlyHeaderLength;

            LOG(_L8("frameType = EBnepCompressedEthernetSourceOnly;"));

            LOG1(_L8("headerLength = %d"),headerLength);

            }

        else 

            {

            if (sendDest)

                {

                frameType = EBnepCompressedEthernetDestOnly;

                headerLength = KCompressedEthernetDestOnlyHeaderLength;

                LOG(_L8("frameType = EBnepCompressedEthernetDestOnly;"));

                LOG1(_L8("headerLength = %d"),headerLength);

                }

            else

                {

                frameType = EBnepCompressedEthernet;

                headerLength = KCompressedEthernetHeaderLength;

                LOG(_L8("frameType = EBnepCompressedEthernet"));

                LOG1(_L8("headerLength = %d"),headerLength);

                }

            }

        }

    aChain.AllocL(headerLength);

	if(Includes(EExtensionHeaders))

		{

		frameType |= KEBit;

		}

    LOG1(_L8("Setting type to %02x"), frameType);

    TInt offset = 0;

    TPckgBuf<TUint8> pkgFrameType(frameType);

    aChain.CopyIn(pkgFrameType, offset++);

    if (sendDest)

        {

        LOG_BT(_L8("Inserting destination address %S"), iDestAddr);

        aChain.CopyIn(iDestAddr.Des(), offset);

        offset += KBTDevAddrSize;

        }

    if (sendSrc)

        {

        LOG_BT(_L8("Inserting source address %S"), iSrcAddr);

        aChain.CopyIn(iSrcAddr.Des(), offset);

        offset += KBTDevAddrSize;

        }

	// Set-up the protocol ID to use for this packet.

	TUint16 protocol = (aFilterEthernetPayload ? 0x0000 : iProtocol);

    aChain.AppendL(KNetworkProtocolTypeFieldLength);

    TBuf8<KNetworkProtocolTypeFieldLength> protocolBuf;

    protocolBuf.SetMax();

    if (Includes(EHas1Q))

        {

        BigEndian::Put16(&protocolBuf[0], static_cast<TUint16>(KQTag));

        }     

    else

        {

        BigEndian::Put16(&protocolBuf[0], static_cast<TUint16>(protocol));

        }

    aChain.CopyIn(protocolBuf, offset);

    offset += KNetworkProtocolTypeFieldLength;

    // Cannot just append the ethernet payload mbufs, because if this is a 

    // multicast frame, this will corrupt it for others

    RMBufChain finalPacket;

    CleanupStack::PushL(finalPacket); // This will call Free() as its cleanup

    iFramePayload.CopyL(finalPacket);

	// Filter out the ethernet payload if required.

	if(aFilterEthernetPayload)

		{

		TInt payloadOffset = 0;

		// Find the start of the ethernet payload.

	    TBuf8<KExtensionHeaderHeaderBytes> buf;

		buf.SetMax();

		TUint8 ebit = ETrue;

		while(ebit)

			{

			// The extension must be long enough for the header.

	        if((payloadOffset + KExtensionHeaderHeaderBytes) > finalPacket.Length())

	            {	

	            User::Leave(KErrCorrupt);

	            }

			// Move the offset to the next extension header.

	    	finalPacket.CopyOut(buf, payloadOffset);

			ebit = buf[0] & KEBit;

			payloadOffset += (buf[1] + KExtensionHeaderHeaderBytes);

			}

		// If the packet includes IEEE 802.1Q fields then these should remain.

		// The network protocol field should be set to zero. 

	    if(Includes(EHas1Q))

	        {

			if((payloadOffset + KIEEE802_1QTagFieldLength + KNetworkProtocolTypeFieldLength) > finalPacket.Length())

				{

				User::Leave(KErrCorrupt);

				}

			protocolBuf[0] = 0;

			protocolBuf[1] = 0;

        	finalPacket.CopyIn(protocolBuf, payloadOffset + KIEEE802_1QTagFieldLength);

			payloadOffset += (KIEEE802_1QTagFieldLength + KNetworkProtocolTypeFieldLength);

	        }

		// The extension headers are finished.  Remove any remaining data.

		finalPacket.TrimEnd(payloadOffset);

		}

	// Append will take ownership of finalPacket

	CleanupStack::Pop(); // finalPacket

	// Add any payload onto the chain.

    aChain.Append(finalPacket);

    LOG1(_L8("RBnepFrame::BuildBnepDataFrameL final Chain length = %d"),aChain.Length());

    }

void RBnepFrame::BuildBnepFrameL(RMBufChain& aChain, const TBTDevAddr& aLocalAddr, const TBTDevAddr& aRemoteAddr, TBool aFilterEthernetPayload)

    {

    /**

       Build a BNEP frame from encapsulated data.

       Processes the data carried by this frame to build a frame which can

       be sent to a remote PAN device.  This involves compressing off any

       addresses which are not required for this link and inserting any

       extension headers.

       @param aChain The target MBufChain to build into.

       @param aLocalAddr The address of the local PAN node.

       @param aRemoteAddr The address of the remote PAN node.

       @internalComponent

    */

    LOG_FUNC

    if (Includes(EControl))

        {

        BuildBnepControlFrameL(aChain);

        }

    else

        {

        BuildBnepDataFrameL(aChain, aLocalAddr, aRemoteAddr, aFilterEthernetPayload);

        }

    }

void RBnepFrame::BuildEthernetFrameL(RMBufPacket& aChain)

    {

    /**

       Builds an ethernet frame from the BNEP frame.

       This function ignores away any control data present and simply inserts all

       addresses, protocol and 802.1Q data, as well as the data payload.

       This function always builds an Ethernet II format frame.  This should be

       accepted by the ethernet NIF, even if it is configured to send in LLC/SNAP

       format.  This behaviour is unlikely to change as it would be valid for a

       remote wired station to send a mixture of packet formats.  As the packet

       driver has no way of knowing which format has been configured, our options

       here are limited.

       @param aChain The MBufPacket to build the packet into.

       @internalComponent

    */

    LOG_FUNC

    // WARNING! Potential for a memory leak follows. 

    // Remember to free this RMBufChain before you exit.

    RMBufChain tempFrame;

	CleanupStack::PushL(tempFrame);

    LOG(_L8("Attempting to copy payload"));

	// Check there is a valid payload 

    if(iFramePayload.IsEmpty())

        {

        LOG(_L8("No payload"));

        User::Leave(KErrUnderflow);

        }

	iFramePayload.CopyL(tempFrame);

    // Any extensions need to be removed.

    if(Includes(EExtensionHeaders))

        {

	    TBuf8<KExtensionHeaderHeaderBytes> buf;

		buf.SetMax();

		TUint8 ebit = ETrue;

		while(ebit)

			{

			// The extension must be long enough for the header.

	        if((KExtensionHeaderHeaderBytes) > tempFrame.Length())

	            {	

	            User::Leave(KErrCorrupt);

	            }

			// Move the offset to the next extension header.

	    	tempFrame.CopyOut(buf, 0);

			ebit = buf[0] & KEBit;

			tempFrame.TrimStart(buf[1] + KExtensionHeaderHeaderBytes);

			}

        }

	// Check there is some data to send.

	if(Includes(EHas1Q) && (tempFrame.Length() <= (KIEEE802_1QTagFieldLength + KNetworkProtocolTypeFieldLength)) ||

	   tempFrame.IsEmpty())

		{

		LOG(_L8("No data to send pass up."));

		User::Leave(KErrUnderflow);

		}

	// Add protocol.

	TUint16 protocol = (Includes(EHas1Q) ? KQTag : iProtocol);

    TBuf8<KNetworkProtocolTypeFieldLength> protocolBuf;

    protocolBuf.SetMax();                                                                                                      

	tempFrame.PrependL(KNetworkProtocolTypeFieldLength);

    BigEndian::Put16(&protocolBuf[0], static_cast<TUint16>(protocol));

    tempFrame.CopyIn(protocolBuf);

	// Add addresses

	tempFrame.PrependL(KBTDevAddrSize);

    LOG_BT(_L8("Inserting source address %S"),iSrcAddr);

    tempFrame.CopyIn(iSrcAddr.Des());

	tempFrame.PrependL(KBTDevAddrSize);

    LOG_BT(_L8("Inserting destination address %S"),iDestAddr);

    tempFrame.CopyIn(iDestAddr.Des());

	// This should be removed when defect DEF066321 is fixed.

	TInt alignLength = Min(tempFrame.Length(), KMBufSmallSize);

	if(tempFrame.Align(alignLength) != alignLength)

		{

		User::Leave(KErrCorrupt);

		}

	RMBufQ tempQueue;

	tempQueue.Assign(tempFrame);

	CleanupStack::Pop();		// Remove tempFrame from the cleanup stack

	CleanupStack::PushL(tempQueue);

	aChain.CreateL(tempQueue); 	

	CleanupStack::PopAndDestroy();		// Remove tempQueue from the cleanup stack

							// As RMBufQs provide support for normal cleanup stack 

							// usage, this will cause the Q to be Free()ed.

	// Create the flags field for the packet info header.

	// Mark the packet as being from BNEP

	TUint flags = KBnep;

	// Check if this packet can be forward to DHCP / NAPT

	if(iUplinkAccessAllowedForBnepLink)

		{

		flags |= KBnepForwardingAllowed;

		}

	aChain.Info()->iFlags = flags;

    aChain.Pack();

    }

const TBTDevAddr& RBnepFrame::DestAddr () const

    {

    LOG_FUNC

    return iDestAddr; 

    }

RBnepFrame::TDestAddrType RBnepFrame::DestinationType () const

    {

    /**

       Return the type of destination for the frame (local, multicast address,

       or a specified machine).

       @internalComponent

    */

    LOG_FUNC

    if (TBTDevAddr(0) == iDestAddr) 

        {

        return ELocal;

        }

    if (BnepUtils::IsMulticast(iDestAddr)) 

        {

        return EMulticast;

        }

    return ENormal; 

    }

TBool RBnepFrame::Includes (TPacketContents aContent) const

    {

    /**

       Accessor function for contents of packet.

       @param aContent The type of content to check for.

       @internalComponent

    */

    LOG_FUNC

    return (iPacketContents & static_cast<TUint8>(aContent));

    }

void RBnepFrame::InsertControl (RBnepControl* aCommand)

    {

    /**

       Inserts and takes ownership of a BNEP command.

       @param aCommand The command to insert into the frame.  The method takes

       ownership of the object, which should be heap based.

       @internalComponent

    */

    LOG_FUNC

    //iCommandQueue.AddLast(*aCommand);

    iCommandQueue.AddLast(*aCommand);

    SetContents(EControl); 

    }

TBnepPacketType RBnepFrame::ParseBnepFrameL (RMBufChain& aInboundChain, const TBTDevAddr& aLocalAddr, const TBTDevAddr& aRemoteAddr)

    {

    /**

       Parse a supplied BNEP frame.

       Parses the provided BNEP frame, separating data and control messages and

       resolving any source and destination addresses.

       @param aInboundChain The frame received from the remote device

       @param aLocalAddr The address of the bridge (the local PAN node and possible

       destination of the packet)

       @param aRemoteAddr The address of the remote PAN node (the possible source

       of the packet)

       @internalComponent

    */

    LOG_FUNC

    if(aInboundChain.Length() < 1)

        {

        User::Leave(KErrUnderflow);

        }

    Reset();

    // Extract the packet type and the Extension bit.

    TBnepPacketType type = static_cast<TBnepPacketType>(aInboundChain.First()->Ptr()[0]);

    aInboundChain.TrimStart(sizeof(TUint8));

    // Test the extension bit

    TBool ebit = type & KEBit;

    // Discard the extension bit

    type = static_cast<TBnepPacketType>(type & (~KEBit));

    LOG1(_L8("Type 0x%02x"),type);

    LOG1(_L8("Ebit 0x%02x"),ebit);

    // Based on the packet type, determine whether to extract addresses

    TBool dest = EFalse;

    TBool src = EFalse;

    switch (type)

        {

        case EBnepGeneralEthernet:

            // General ethernet -- both source and destination present

            LOG(_L8("Type = EBnepGeneralEthernet"));

            SetContents(EDataFrame);

            dest = ETrue;

            src = ETrue;

            break;

        case EBnepControl:

            // Control -- no addresses present (or any data)

            LOG(_L8("Type = EBnepControl"));

            break;

        case EBnepCompressedEthernetDestOnly:

            // Comressed destination only -- only destination present

            LOG(_L8("Type = EBnepCompressedEthernetDestOnly"));

            SetContents(EDataFrame);

            dest = ETrue;

            break;

        case EBnepCompressedEthernetSourceOnly:

            // Compressed source only -- only source present

            LOG(_L8("Type = EBnepCompressedEthernetSourceOnly"));

            SetContents(EDataFrame);

            src = ETrue;

            break;

        case EBnepCompressedEthernet:

            // Compressed -- no addresses present

            LOG(_L8("Type = EBnepCompressedEthernet"));

            SetContents(EDataFrame);

            break;