/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2008,2009 IITP RAS

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as 

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Kirill Andreev <andreev@iitp.ru>

 */

#include "ns3/node.h"

#include "ns3/channel.h"

#include "ns3/packet.h"

#include "ns3/log.h"

#include "ns3/boolean.h"

#include "ns3/simulator.h"

#include "ns3/l2-routing-net-device.h"

NS_LOG_COMPONENT_DEFINE ("L2RoutingNetDevice");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (L2RoutingNetDevice);

TypeId

L2RoutingNetDevice::GetTypeId (void)

{

	static TypeId tid = TypeId ("ns3::L2RoutingNetDevice")

		.SetParent<NetDevice> ()

		.AddConstructor<L2RoutingNetDevice> ()

		;

	return tid;

}

L2RoutingNetDevice::L2RoutingNetDevice ()

{

	NS_LOG_FUNCTION_NOARGS ();

	m_channel = CreateObject<BridgeChannel> ();

}

L2RoutingNetDevice::~L2RoutingNetDevice()

{

	NS_LOG_FUNCTION_NOARGS ();

}

	void

L2RoutingNetDevice::DoDispose ()

{

	NS_LOG_FUNCTION_NOARGS ();

	for (std::vector< Ptr<NetDevice> >::iterator iter = m_ports.begin (); iter != m_ports.end (); iter++)

		*iter = 0;

	m_ports.clear ();

	m_node = 0;

	NetDevice::DoDispose ();

}

	void

L2RoutingNetDevice::ReceiveFromDevice (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet, uint16_t protocol,

		Address const &src, Address const &dst, PacketType packetType)

{

	NS_LOG_FUNCTION_NOARGS ();

	NS_LOG_DEBUG ("UID is " << packet->GetUid ());

	const Mac48Address src48 = Mac48Address::ConvertFrom (src);

	const Mac48Address dst48 = Mac48Address::ConvertFrom (dst);

	if (!m_promiscRxCallback.IsNull ())

		m_promiscRxCallback (this, packet, protocol, src, dst, packetType);

	switch (packetType)

	{

		case PACKET_HOST:

			if (dst48 == m_address)

				m_rxCallback (this, packet, protocol, src);

			break;

		case PACKET_BROADCAST:

		case PACKET_MULTICAST:

			m_rxCallback (this, packet, protocol, src);

		case PACKET_OTHERHOST:

			Forward (incomingPort, packet->Copy(), protocol, src48, dst48);

			break;

	}

}

void

L2RoutingNetDevice::Forward (Ptr<NetDevice> inport, Ptr<Packet> packet,

		uint16_t protocol, const Mac48Address src, const Mac48Address dst)

{

	//pass through routing protocol

	m_requestRoute(inport->GetIfIndex(), src, dst, packet, protocol, m_myResponse);

}

uint32_t

L2RoutingNetDevice::GetNPorts (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_ports.size ();

}

Ptr<NetDevice>

L2RoutingNetDevice::GetPort (uint32_t n) const

{

	NS_ASSERT(m_ports.size () > n);

	return m_ports[n];

}

void

L2RoutingNetDevice::AddPort (Ptr<NetDevice> routingPort)

{

	NS_LOG_FUNCTION_NOARGS ();

	NS_ASSERT (routingPort != this);

	if (!Mac48Address::IsMatchingType (routingPort->GetAddress ()))

		NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be added to bridge.");

	if (!routingPort->SupportsSendFrom ())

		NS_FATAL_ERROR ("Device does not support SendFrom: cannot be added to bridge.");

	m_address = Mac48Address::ConvertFrom (routingPort->GetAddress ());

	NS_LOG_DEBUG ("RegisterProtocolHandler for " << routingPort->GetName ());

	m_node->RegisterProtocolHandler (MakeCallback (&L2RoutingNetDevice::ReceiveFromDevice, this),

			0, routingPort, true);

	m_ports.push_back (routingPort);

	m_channel->AddChannel (routingPort->GetChannel ());

}

	void

L2RoutingNetDevice::SetName(const std::string name)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_name = name;

}

std::string

L2RoutingNetDevice::GetName(void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_name;

}

	void

L2RoutingNetDevice::SetIfIndex(const uint32_t index)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_ifIndex = index;

}

uint32_t

L2RoutingNetDevice::GetIfIndex(void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_ifIndex;

}

Ptr<Channel>

L2RoutingNetDevice::GetChannel (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_channel;

}

Address

L2RoutingNetDevice::GetAddress (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_address;

}

	bool

L2RoutingNetDevice::SetMtu (const uint16_t mtu)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_mtu = mtu;

	return true;

}

uint16_t

L2RoutingNetDevice::GetMtu (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return 1500;

}

bool

L2RoutingNetDevice::IsLinkUp (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return true;

}

	void

L2RoutingNetDevice::SetLinkChangeCallback (Callback<void> callback)

{}

bool

L2RoutingNetDevice::IsBroadcast (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return true;

}

Address

L2RoutingNetDevice::GetBroadcast (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return Mac48Address ("ff:ff:ff:ff:ff:ff");

}

bool

L2RoutingNetDevice::IsMulticast (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return true;

}

Address

L2RoutingNetDevice::GetMulticast (Ipv4Address multicastGroup) const

{

	NS_LOG_FUNCTION (this << multicastGroup);

	Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);

	return multicast;

}

bool

L2RoutingNetDevice::IsPointToPoint (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return false;

}

bool

L2RoutingNetDevice::IsBridge (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return false;

}

bool

L2RoutingNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

{

	const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);

	return m_requestRoute(m_ifIndex, m_address, dst48, packet, protocolNumber, m_myResponse);

}

bool

L2RoutingNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)

{

	const Mac48Address src48 = Mac48Address::ConvertFrom (src);

	const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);

	return m_requestRoute(m_ifIndex, src48, dst48, packet, protocolNumber, m_myResponse);

}

Ptr<Node>

L2RoutingNetDevice::GetNode (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return m_node;

}

	void

L2RoutingNetDevice::SetNode (Ptr<Node> node)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_node = node;

}

bool

L2RoutingNetDevice::NeedsArp (void) const

{

	NS_LOG_FUNCTION_NOARGS ();

	return true;

}

	void

L2RoutingNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_rxCallback = cb;

}

	void

L2RoutingNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)

{

	NS_LOG_FUNCTION_NOARGS ();

	m_promiscRxCallback = cb;

}

bool

L2RoutingNetDevice::SupportsSendFrom () const

{

	NS_LOG_FUNCTION_NOARGS ();

	return true;

}

Address

L2RoutingNetDevice::GetMulticast (Ipv6Address addr) const

{

	NS_LOG_FUNCTION (this << addr);

	return Mac48Address::GetMulticast (addr);

}

//L2RouitingSpecific methods:

bool

L2RoutingNetDevice::AttachProtocol(Ptr<L2RoutingProtocol> protocol)

{

	m_requestRoute = MakeCallback(&L2RoutingProtocol::RequestRoute, protocol);

	m_myResponse = MakeCallback(&L2RoutingNetDevice::ProtocolResponse, this);

	protocol->SetIfIndex(m_ifIndex);

	return protocol->AttachPorts(m_ports);

}

void

L2RoutingNetDevice::ProtocolResponse(

		bool success,

		Ptr<Packet> packet,

		Mac48Address src,

		Mac48Address dst,

		uint16_t protocol,

		uint32_t outPort

		)

{

	if(!success)

	{

		NS_LOG_UNCOND("Resolve failed");

		//TODO: SendError callback

		return;

	}

	//just do sendFrom!

	if(outPort!=0xffffffff)

		GetPort(outPort)->SendFrom(packet, src, dst, protocol);

	else

		for(std::vector<Ptr<NetDevice> >::iterator i = m_ports.begin(); i!= m_ports.end(); i++)

			(*i) -> SendFrom(packet, src, dst, protocol);

}

} // namespace ns3