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

// Implementation CLanIp4Bearer class, a derived from CLanxBearer.

// History

// 15/11/01 Started by Julian Skidmore.

// 11/03		Refactored as part of DHCP relocation work 

// 

//

/**

 @file

*/

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

#include <in_pkt.h>

#include <in6_if.h>

#include <nifvar.h>

#include <comms-infras/connectionsettings.h>

#include "CLanIp4Bearer.h"

#include "arp_hdr.h"

#include <commdb.h>

#include <cdblen.h>

#include "EthProto.h"

#include "eth_log.h"

#include "ProtocolHeaders.h"

#include <comms-infras/es_protbinder.h>

#include "EthProvision.h"

using namespace ESock;

/**

Required ConstructL() method.  Performs the following:

"	Sets a unique name for this binder instance in the iIfName field - "eth6[0x%x]" where "%x"

    is the hexadecimal address of the "this" object.

"	Reads the IP Interface Settings using ReadIPInterfaceSettingsL().

"	Reads CommDb settings (e.g. IPv6 static DNS configuration) from the LAN Service Table via 

    ReadCommDbLanSettingsL().

*/

void CLanIp4Bearer::ConstructL()

{ 

	iIfName.Format(_L("eth[0x%08x]"), this);

	// ReadCommDbLanSettingsL() moved from here to point when provisioning information received

}

TInt CLanIp4Bearer::Control(TUint aLevel, TUint aName, TDes8& aOption)

	{

	if ((aLevel==KCOLInterface) || (aLevel==KSOLInterface))

		{

		switch (aName)

			{

			case KSoIfHardwareAddr:

				{

				if (static_cast<TUint>(aOption.Length())<sizeof(TSoIfHardwareAddr))

					{	

					return KErrArgument;

					}

				TSoIfHardwareAddr& opt=*(TSoIfHardwareAddr*)aOption.Ptr();

				opt.iHardwareAddr.SetFamily(1); // Set up the address family type

				opt.iHardwareAddr.SetPort(1);	// Hardware Type, has to be returned in the port field...

				opt.iHardwareAddr.SetLength(8); // The length so far, 4 for family + 4 for port...

				opt.iHardwareAddr.Append(Link()->MacAddress());

	         	return KErrNone;

	         	}

	         default:

	         	return KErrNotSupported;

			}

		}

	return KErrNotSupported;		// keep compiler happy - all returns covered by switch above

	}

_LIT8(KEtherMACMultiCastPrefix,"\x01\x00\x5e");

/**

Call down from the Protocol

Real Protocol data is in the second MBuf of the RMBufChain

The info block contains important addressing information;

  If the destination address family is KAfInet,

    then we must generate the hardware destination address

    since it could not be resolved by ARP. It is probably

    a broadcast or multicast address.

  Otherwise,

    the destination address contains a resolved hardware

    address and we only need to shift the address bytes

    for the lower layer.

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

@param aPdu		A reference to the packet to be sent (really an RMBufPkt)

@param aSource  A pointer to the source protocol.

@return The no. of bytes send.

*/

MLowerDataSender::TSendResult CLanIp4Bearer::Send(RMBufChain& aPdu)

{

	// Check that we are allowed to send data

	if (!Link()->BearerIsActive(this))

		{

			aPdu.Free();

			return ESendBlocked;

		}

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

	if (info->iDstAddr.Family() == KAfInet) 

		{

		// Create hardware addresses for multicast and broadcast destinations

		if (TInetAddr::Cast(info->iDstAddr).IsMulticast())

			{

			TInetAddr multicastDest(TInetAddr::Cast(info->iDstAddr).Address() & KArpMacMulticastMask, 0);

			info->iDstAddr.Copy(KEtherMACMultiCastPrefix);

			TUint32 addr = multicastDest.Address();

			info->iDstAddr.Append((addr&0xff0000)>>16);

			info->iDstAddr.Append((addr&0xff00)>>8);

			info->iDstAddr.Append((addr&0xff));

			}

		else

			// Catch all types of broadcast addresses (including subnet)

			{

			for(TUint ix = 0; ix < KMACByteLength; ix++)

				{

				info->iDstAddr[ix] = 0xff;

				}

			}

		}

	else

		// Shift the already resolved hardware address to the beginning

		{

		for(TUint ix = 0; ix < KMACByteLength; ix++)

			{

			info->iDstAddr[ix] = info->iDstAddr[ix + KDestAddrOffset];

			}

		}

	TInt ret = Link()->FrameSend(aPdu, NULL, (TUint)info->iProtocol == KProtocolArp ? KArpFrameType : KIPFrameType);

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("CLanIp4Bearer::Send() sent packet"));

	return static_cast<MLowerDataSender::TSendResult>(ret);

}

/**

StartSending notifies the protocol that this object is ready to transmit and process data. 

@param aProtocol A pointer to the object which signalled it is ready to StartSending.

*/

void CLanIp4Bearer::StartSending(CProtocolBase* aProtocol)

{

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("CLanIp4Bearer::StartSending()"));

	CLanxBearer::StartSending(aProtocol);

}

/**

WantsProtocol, takes an ethernet aProtocolCode code and the initial part of the packet's 

payload as input and returns ETrue if the bearer wants the packet of this type of protocol 

and payload, or EFalse otherwise. CLanIp4Bearer wants the protocol if it is an Arp message or

an Ip4 protocol (an Ip protocol, whose Version field == 4). WantsProtocol also sets 

iArpMsgNext to ETrue if the protocol was Arp or EFalse otherwise.

@param aProtocolCode The Ethernet protocol Type.

@param aPayload A pointer to the beginning of the packet payload.

@return sets iArpMsgNext to ETrue if the protocol was Arp or EFalse otherwise.

*/

TBool CLanIp4Bearer::WantsProtocol(TUint16 aProtocolCode,const TUint8* aPayload)

{

	return ((aProtocolCode==KIPProtocol && (aPayload[0]>>4)==KIP4Protocol) || (aProtocolCode==KArpFrameType))  ? ETrue:EFalse;

}

/**

Process processes a packet received from the LinkLayer.

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

@param aLLC Unclear.

*/

void CLanIp4Bearer::Process(RMBufChain& aPdu, TAny* aLLC)

{

	__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("CLanIp4Bearer::Process(RMBufChain& aPdu,TAny* aLLC)"));

	if (iUpperReceiver)

		{

		// Set the protocol type in the info header if ARP packet

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

		if (reinterpret_cast<TUint32>(aLLC) == KArpFrameType)

			{

			__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("CLanIp4Bearer::Process() - Received ARP packet"));

			info->iProtocol = KProtocolArp;

			}

		__FLOG_STATIC(KEther802LogTag1, KEthLogTag2, _L("CLanIp4Bearer::Process() - calling iProtocol->Process(aPdu,..)"));

		iUpperReceiver->Process(aPdu);

		}

	else

		{

	  	aPdu.Free();

	  	}

}

/**

ReadCommDbLanSettingsL() reads CommDb settings from the LAN Service Table.  In particular, it

reads the fields related to IPv4 Static DNS configuration.  The LAN_IP4_DNS_ADDR_FROM_SERVER 

field is a boolean that indicates whether IPv4 Static DNS configuration is required or not.  

If FALSE, then static configuration is required.  In this case, the IPv4 primary and secondary 

DNS server addresses are read from the CommDb fields LAN_IP4_NAME_SERVER1 and LAN_IP4_NAME_SERVER2 

and stored in the iPrimaryDns and iSecondaryDns data members.  They are later presented to 

the TCP/IP stack when the Control() method is called with the KSoIfConfig option.

*/

void CLanIp4Bearer::ReadCommDbLanSettingsL()

{

	ASSERT(iProvision);

	iLocalAddr = iProvision->LocalAddr();

	iNetMask = iProvision->NetMask();

	iDefGateway = iProvision->DefGateway();

	iPrimaryDns = iProvision->PrimaryDns();

	iSecondaryDns = iProvision->SecondaryDns();

}

TInt CLanIp4Bearer::GetConfig(TBinderConfig& aConfig)

	{

    TBinderConfig4* config = TBinderConfig::Cast<TBinderConfig4>(aConfig);

	if(config == NULL)

		{

		return KErrNotSupported;

		}

	config->iFamily = KAfInet;		/* KAfInet / KAfInet6 - selects TBinderConfig4/6 */

	config->iInfo.iFeatures = KIfCanBroadcast | KIfCanMulticast | KIfNeedsND;		/* Feature flags */

	config->iInfo.iMtu = Link()->Mtu();					/* Maximum transmission unit. */

	config->iInfo.iRMtu = Link()->Mtu();					/* Maximum transmission unit for receiving. */

	config->iInfo.iSpeedMetric = Link()->SpeedMetric();	/* approximation of the interface speed in Kbps. */

	config->iAddress.SetAddress(iLocalAddr);			/* Interface IP address. */

	config->iNetMask.SetAddress(iNetMask);			/* IP netmask. */

	config->iBrdAddr.SetAddress(iBroadcastAddr);		/* IP broadcast address. */

	config->iDefGate.SetAddress(iDefGateway);		/* IP default gateway or peer address (if known). */

	config->iNameSer1.SetAddress(iPrimaryDns);		/* IP primary name server (if any). */

	config->iNameSer2.SetAddress(iSecondaryDns);		/* IP secondary name server (if any). */

	return KErrNone;

	}

const TDesC8& CLanIp4Bearer::ProtocolName() const

/**

Return the protocol name of this bearer

Called from CLANLinkCommon

*/

	{

	_LIT8(KProtocolName, "ip");

	return KProtocolName();

	}

void CLanIp4Bearer::SetProvisionL(const Meta::SMetaData* aProvision)

	{

	if (iProvision == NULL)

		{

		iProvision = static_cast<const TLanIp4Provision*>(aProvision);

		ReadCommDbLanSettingsL();

		}

	}