// Copyright (c) 1997-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:

// Ethernet and 802.3 protocol suite common link layer (interface) code 

// 

//

/**

 @file

*/

#include <f32file.h>

#include <e32std.h>	// for TTime

#include <nifman.h>

#include <nifvar.h>

#include <nifutl.h>

#include <es_mbuf.h>

#include <nifmbuf.h>

#include <comms-infras/nifprvar.h>

#include <comms-infras/connectionsettings.h>	// for KSlashChar

#include <commdb.h>

#include "EthProto.h"

#include "PKTDRV.H"

#include <in_sock.h> // Header is retained, but in_sock.h is modified for ipv6

#include <d32ethernet.h>

#include "CLanIp4Bearer.h"

#include "CLanIp6Bearer.h"

#include "eth_log.h"

#include <cdbcols.h>

#include <cdblen.h>

#include "CLanxBearer.h"

#include "eth_log.h"

#include "EthProvision.h"

#include <comms-infras/ss_metaconnprov.h>					// for SAccessPointConfig

#include <comms-infras/ss_log.h>

#include <comms-infras/linkmessages.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

using namespace Elements;

_LIT8(KDescIp, "ip");

_LIT8(KDescIcmp, "icmp");

_LIT8(KDescIp6, "ip6");

/**

Constant supports Broadcasting or Multicasting

@internalComponent

*/

/**

Packet driver Function Pointer

@internalComponent

*/

typedef CPktDrvFactory* (*TPktDrvFactoryNewL)();

EXPORT_C CLANLinkCommon::CLANLinkCommon(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

	: CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf), iMMState(EStopped)

{

   	LOG_NODE_CREATE(KEthLogTag2, CLANLinkCommon);

}

/**

Loads, creates and starts the packet driver.

The packet driver's name is found from the LAN service table in commdb.

The name then has '.drv' appended and its driver factory is found using DoFindDriverFactoryL.

If found, the packet driver is created using the factory's NewDriverL method and the driver state is set to EDrvStarted.

@note Should be called from the ConstructL phase of the CLANLinkCommon initialisation.

*/

void CLANLinkCommon::LoadPacketDriverL()

{

	TBuf<KCommsDbSvrDefaultTextFieldLength+4> drvName;	// plus 4 is for the filename extension added below

	ASSERT(iLanLinkProvision);

	if (LinkProvision().PacketDriverName().Length() == 0)

		{

		__FLOG_STATIC(KEther802LogTag1,KEthLogTag2, _L("Empty packet driver name - is .cfg file up-to-date?  See ether802.ini for information on required fields in commdb."));

		User::Leave(KErrArgument);

		}

	drvName.Copy(LinkProvision().PacketDriverName());

	if(!(drvName.Right(4)==KPacketDriverFileExtension())) // no != for comparing strings, so a bit of laboured logic

		{

		drvName.Append(KPacketDriverFileExtension);

		}

	// Ref counted library ownership to ensure the library is not unloaded prematurely

	CPktDrvFactory* pktFactory = (CPktDrvFactory *)DoCreateDriverFactoryL(TUid::Uid(KUidNifmanPktDrv), drvName);

	CleanupStack::PushL(pktFactory);

	iPktDrvOwner = new(ELeave)CPacketDriverOwner(pktFactory);

	CleanupStack::Pop();

	iPktDrvOwner->Open();

	iPktDrv=pktFactory->NewDriverL(this);

}

EXPORT_C CLANLinkCommon* CLANLinkCommon::NewL(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

	{

	CLANLinkCommon* s=new (ELeave) CLANLinkCommon(aFactory, aSubConnId, aProtocolIntf);

	CleanupStack::PushL(s);

	s->ConstructL();

	CleanupStack::Pop();

	return s;

	}

/** Ethernet Type - Encapsulation

@internalComponent

*/

_LIT(KEtherType,"encapsulation");

/**

Reads the Link layer Ethernet settings in Ether802.ini. Currently this is just the ethernet

encapsulation type, stored in parameter encapsulation in section [ethernet], sets iEtherType

on the basis of the encapsulation type: ELLCEthernet, if the encapsulation parameter = 1, or

EStandardEthernet otherwise.

*/

void CLANLinkCommon::ReadEthintSettingsL()

{

	CESockIniData* ini = CESockIniData::NewL(ETHER802_CONFIG_FILENAME);

	CleanupStack::PushL(ini);

	TInt encapType = 0;

	ini->FindVar(KEthernetSection,KEtherType,encapType);

	CleanupStack::PopAndDestroy();

	switch(encapType)

		{

		case 0 :

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("Framing type set to Ethernet II"));

			iEtherType=EStandardEthernet;

			break;

		case 1 :

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("Framing type set to IEEE802.3 LLC-SNAP"));

			iEtherType=ELLCEthernet;

			break;

		default :

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("Unrecognised or no framing type in config file - framing type set to Ethernet II"));

			iEtherType=EStandardEthernet;  // not a valid type

		}

}

/**

Implementation of the pure virtual from CLANLinkBase, for use by the bearers. Returns the

hardware interface obtained from the packet layer in the aBuffer descriptor in a 6 byte binary

Big-endian format.

@return ETrue if the hardware address was non-zero, EFalse otherwise.

*/

TBool CLANLinkCommon::ReadMACSettings()

{

	TBuf8<KMACByteLength> drvMacAddr;

	TUint8* config=iPktDrv->GetInterfaceAddress();

	drvMacAddr.Append(&config[0],KMACByteLength); // First 3 bytes of config not part of address

	iMacAddr.Copy(drvMacAddr); // update Ethints copy of the MAC address

	TUint bearerLim = iBearers->Count();

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

		{

		CLanxBearer* bearer=(*iBearers)[index];

		bearer->UpdateMACAddr();

		}

	// check that the macaddress has been passed and is not 0;

	return CheckMac(iMacAddr); // wrong.

}

TUint CLANLinkCommon::Mtu() const

{

	if(iEtherType==ELLCEthernet)

		{

		__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("MTU - value for LLC frames"));

		return KEtherMaxFrame;

		}

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("MTU - default setting"));

	return KDefaultMtuSetting;

}

/**

The CLANLinkCommon::ConstructL performs all the memory allocating initialisations. It's

iContainer is allocated, using NewL; its iPktDriverFactories is created using its

iContainer->CreateL. A dynamic array of 16 iBearers are created.

@param TDesC Unused

*/

EXPORT_C void CLANLinkCommon::ConstructL()

{

	__FLOG_STATIC(KEther802LogTag1,KEthLogTag2, _L("Ethint started"));

	// Initialise class members that do not need to be read from the database

	iBearers = new (ELeave) CLanxBearerPtrArray(16);

	iOnlyThisBearer = NULL;

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("Reading Ethint settings"));

	ReadEthintSettingsL();

#ifdef TCPDUMP_LOGGING

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("Libpcap format logging enabled"));

	iLogger = CEthLog::NewL();

	iLogger->DumpTcpDumpFileHeader();

#endif // TCPDUMP_LOGGING

}

/**

Destructor. If there are any iPktDrvFactories, these are deleted first, by closing each Factory's

RLibrary iLib handle and then deleting the object. Then all the bearers are deleted . Finally,

the packet driver, the logical device driver and the physical device driver are freed and then

the packet driver is deleted.

*/

EXPORT_C  CLANLinkCommon::~CLANLinkCommon()

{

#ifdef TCPDUMP_LOGGING

	delete iLogger;

#endif // TCPDUMP_LOGGING

	delete iPktDrv;

	if(iPktDrvOwner != NULL ) // iPktDrvOwner may not be created if leave occurs while loading the driver.

	{

		iPktDrvOwner->Close();

	}

	ASSERT(0 == iBearers->Count());

	delete iBearers;

   	LOG_NODE_DESTROY(KEthLogTag2, CLANLinkCommon);

}

/**

Checks the descriptor for a valid (non-zero) MAC address.

@param aMacAddr A reference to a the descriptor containing the new MAC

@return ETrue if the MAC address was non-zero, EFalse otherwise.

*/

TBool CLANLinkCommon::CheckMac(TDes8& aMacAddr)

{

	for (TUint i=0;i<=5;i++)

		{

		if (aMacAddr[i] != 0)

			return ETrue;

		}

	return EFalse;

}

/**

This method is intended for use when a device does not have the correct MAC address when ARP is started

(e.g. IRLAN). It must be called by the packet driver as soon as an interface address is available.

It should be called before the packet driver sends LinkLayerUp to nifman,otherwise packets could

be sent with an invalid hardware address.

*/

EXPORT_C void CLANLinkCommon::FoundMACAddrL()

{

	iValidMacAddr = ReadMACSettings();

}

/**

Link Layer Up

Called by the packet driver when it is happy

@internalTechnology

*/

EXPORT_C void CLANLinkCommon::LinkLayerUp()

{

	//some drivers have a valid MAC only after negotiation finishes

	iValidMacAddr = ReadMACSettings();

	PostDataClientStartedMessage();

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L ("CLANLinkCommon::LinkLayerUp()"));

	/**

	   With the new comms framework, this KLinkLayerOpen always sent and then will be caught and swallowed

	   at the ipproto layer if a netcfgext is being used. */

#ifndef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	if (LinkProvision().ConfigDaemonName().Length() == 0)

  		{

#endif

#ifndef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

		}

#endif

	TUint bearerLim = iBearers->Count();

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

		{

		CLanxBearer *bearer=(*iBearers)[index];

		bearer->StartSending((CProtocolBase*)this);

		}

}

EXPORT_C void CLANLinkCommon::LinkLayerDown(TInt aError, TAction aAction) // Notify the Protocol that the line is down

/**

Link Layer Down

Called by the packet driver when the link has gone down

@param aError error code

@param aAction whether a reconnect is required or not

@internalTechnology

*/

	{

	// If a stop was requested from the SCpr then this LinkLayerDown()

	// was expected. This also means the SCpr has already been sent a

	// TCFDataClient::TStopped and the packet driver has been stopped.

	// If on the other hand the stop was not requested a TDataClientGoneDown

	// message needs to be sent to the SCpr and the packet driver still

	// needs a StopInterface call - usually this would mean that aAction

	// is EReconnect

	if (iStopRequested == EFalse && iMMState == EStarted)

	    {

	    PostFlowGoingDownMessage(aError, (aAction == EReconnect) ? MNifIfNotify::EReconnect : MNifIfNotify::EDisconnect);

	    iPktDrv->StopInterface();

		iMMState = EStopped;

	    }

	}

/**

Given the RMBufChain &aPdu, which contains a PktInfo at the start, Convert the PktInfo into

an ether frame header. The source and dest address is already assumed to be filled, i.e.

multi-cast or whatever. aPdu is returned modified.

@param aPdu  Contains a PktInfo.

@param aType The Ether type for the packet,

@return  An error code, KErrNone if the Ethernet header could be prepended, or KErrGeneral

		 if it could not.

*/

TInt CLANLinkCommon::EtherFrame(RMBufChain &aPdu, TUint16 aType)

{

	TInt ret;

	//To start with, we need a buffer for the ethernet header,

	//and the packet info.

	//Create an ether header

	RMBufChain ethHdr;

	TUint etherHeaderSize = (iEtherType==EStandardEthernet) ?

	KEtherHeaderSize : KEtherLLCHeaderSize;

	TRAP(ret, ethHdr.AllocL(etherHeaderSize));

	if (ret != KErrNone)

		{

		return ret;

		}

	TEtherLLCFrame *hdrBuf=(TEtherLLCFrame*)ethHdr.First()->Buffer();

	//Get the packet info:

	RMBufPktInfo* info = RMBufPacket::PeekInfoInChain(aPdu);

	// Fill in the dest, src Mac addresses:

	hdrBuf->SetDestAddr(info->iDstAddr);

	hdrBuf->SetSrcAddr(iMacAddr);

	switch(iEtherType)

		{

		case EStandardEthernet:

			BigEndian::Put16((TUint8*)&hdrBuf->iTypeLen,aType);

			break;

		case ELLCEthernet:

			// Several fields to fill in. According to nifmbuf.h,

			// info->iLength gives the actual length of the packet.

			BigEndian::Put16((TUint8*)&hdrBuf->iTypeLen,static_cast<TInt16>(info->iLength));

			hdrBuf->iDSAP=KLLC_SNAP_DSAP;

			hdrBuf->iSSAP=KLLC_SNAP_SSAP;

			hdrBuf->iCtrl=KLLC_SNAP_CTRL;

			hdrBuf->SetOUI(0);

			hdrBuf->SetType(aType);

			break;

		default:

			// Can't handle any other kind of Ethernet header.

			return KErrGeneral;

		}

	//Remove the original first Packet - by trimming the info from the packet.

	TUint dummyLength=aPdu.Length(); // At this point, info becomes invalid.

	aPdu.TrimStart(dummyLength-info->iLength);

	//Finally, add the saved packet buffer to the mac header

	aPdu.Prepend(ethHdr);

	return KErrNone;

}

/**

FrameSend frames the aPdu packet, giving it a type field defined by aType and then sends it via

the packet driver's Send method, returning its return value. If there is an error framing the

packet, the packet is dropped and KErrGeneral is returned.

@param aPdu      The Packet to be sent (actually an RMBufPkt).

@param aProtocol A pointer to the protocol which sent the packet (ignored)

@param aType     The Type field in the Ethernet header when framing. For iEtherFrame== EStandardEthernet,

				 this is stored in the iType field, for ELLCEthernet, this is stored in the

				 iTypeHi:iTypeLo fields.

@return 0 Tells the higher layer to send no more data else

		1 Tells higher layer that it can send more data

*/

TInt CLANLinkCommon::FrameSend(RMBufChain& aPdu,TAny* /*aProtocol*/, TUint16 aType)

{

	// Call down from the Protocol

	// The data begins in the second MBuf - because the first one

	// is the info. The upper layer must have filled in the destination

	// and source Mac addresses before this method is called and must

	// supply the ether header type in aType.

	// EtherFrame strips off the info and replaces it by the proper

	// ether header.

	// Caller Flow controls off if the return to this method is <= 0

	if(EtherFrame(aPdu,aType)==KErrNone)

		{

		// Dump it to the log in pcap format

#ifdef TCPDUMP_LOGGING

		//Find absolute time now

		TTime timeNow;

		timeNow.HomeTime();

		iLogger->DumpFrame(timeNow,aPdu);

#endif

		return iPktDrv->Send(aPdu);

		}

	else

		{ // drop the packet and return an error - incorrectly formatted.

		// which error though?

		aPdu.Free();

		}

	return KErrGeneral; // Should be a better error code though.

}

/**

GetProtocolType extracts protocol header information from an ethernet packet and is called

when processing a packet.

@param  aPdu			 An Ethernet packet (actually, it is really an RMBufPkt with a packed

						 info, not an RMBufChain)

@param  aEtherType       The Ether type for the packet, which is the type field for the packet,

						 for example: KIPFrameType (=0x800) or KIP6FrameType (0x8dd). Note:

						 GetProtocolType makes no restrictions on valid EtherTypes, since

						 this is handled by the bearers.

@param  aPayloadPtr      A pointer to the beginning of the actual payload after the Ethernet

					     header (or the Ethernet LLC header).

@param  aEtherHeaderSize The size of the Ethernet header, either the standard ethernet header

						 size (KEtherHeaderSize==14), or the LLC header size (KEtherLLCHeaderSize= standard+8).

@return An error code, KErrNone, if a valid procol type could be extracted, or KErrNotSupported otherwise.

*/

TInt CLANLinkCommon::GetProtocolType(RMBufChain& aPdu,

									 TUint16& aEtherType, TUint8*& aPayloadPtr,

									 TUint& aEtherHeaderSize) const

{

	RMBuf* chnptr=aPdu.First(); // Start of received packet

	// Start of actual packet data  (Ethernet II)

	TEtherFrame *etherFrame=(TEtherFrame*)(chnptr->Next()->Ptr());

	if ((aEtherType=etherFrame->GetType())>=1536)

		{ // Standard Ethernet type

		__ASSERT_DEBUG(chnptr->Next()->Length() >= KEtherHeaderSize, Panic(EIeee802AddrBadMBuf));

		__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L ("CLANLinkCommon::GetProtocolType ()  Got Ethernet-II-type frame"));

		if (chnptr->Next()->Length() == KEtherHeaderSize)

			{

			aPayloadPtr = chnptr->Next()->Ptr();

			}

		else

			{

			aPayloadPtr = etherFrame->iData;

			}

		aEtherHeaderSize=KEtherHeaderSize;

		}

	else // It's an LLC Ethernet frame (802.3)

		{

		if(chnptr->Next()->Length() >= KEtherLLCHeaderSize)

		    {

		    TEtherLLCFrame *etherLLCFrame = (TEtherLLCFrame*)etherFrame;

		    if(etherLLCFrame->iDSAP==KLLC_SNAP_DSAP &&

			etherLLCFrame->iSSAP==KLLC_SNAP_SSAP &&

			etherLLCFrame->iCtrl==KLLC_SNAP_CTRL)

			{ // Valid LLC-SNAP Frame.

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L ("CLANLinkCommon::GetProtocolType ()  Got 802.3-type frame, with LLC and SNAP headers"));

			aEtherType=etherLLCFrame->GetType(); // Standard Ethernet type.

			aPayloadPtr=etherLLCFrame->iData;

			aEtherHeaderSize=KEtherLLCHeaderSize;

			}

		    else

			{

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L ("CLANLinkCommon::GetProtocolType ()  Got what initially looked like a 802.3-type frame, but no SNAP header"));

			aEtherType=0;

			aPayloadPtr=0;

			aEtherHeaderSize=0;

			return KErrNotSupported;

			}

		    }

		else

		    {

	            return KErrCorrupt;

		    }

		}

	return KErrNone;

}

/**

Process processes a packet received from the packet driver.

@param aPdu The Packet to be sent (actually an RMBufPkt).

@param aLLC Unclear.

*/

EXPORT_C void CLANLinkCommon::Process(RMBufChain& aPdu, TAny* /*aLLC*/)

{

	TUint16 etherCode;

	TUint8* etherPtr;

	TUint etherHeaderSize;

	TBool packetProcessed=EFalse;

	TInt ret=GetProtocolType(aPdu,etherCode,etherPtr,etherHeaderSize);

	if (ret==KErrNone)

		{ // It's an ethernet packet of some kind.

		// Dump it to the log in pcap format

#ifdef TCPDUMP_LOGGING

		//Find absolute time now

		TTime timeNow;

		timeNow.HomeTime();

		RMBufPacket& pkt = (RMBufPacket&)aPdu;

		pkt.Unpack();

		iLogger->DumpFrame(timeNow,aPdu);

		pkt.Pack();

#endif

		TUint bearerLim = iBearers->Count();

		for(TUint index=0;index<bearerLim && !packetProcessed;index++)

			{

			CLanxBearer* bearer=(*iBearers)[index];

			if (BearerIsActive(bearer))