294 lines
7.8 KiB
C++
294 lines
7.8 KiB
C++
// -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*-
|
|
//
|
|
// Copyright (c) 2008 University of Washington
|
|
//
|
|
// 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
|
|
//
|
|
|
|
#include "ns3/log.h"
|
|
#include "ns3/object.h"
|
|
#include "ipv4-global-routing.h"
|
|
#include "ns3/packet.h"
|
|
#include "ns3/node.h"
|
|
|
|
NS_LOG_COMPONENT_DEFINE ("Ipv4GlobalRouting");
|
|
|
|
namespace ns3 {
|
|
|
|
NS_OBJECT_ENSURE_REGISTERED (Ipv4GlobalRouting);
|
|
|
|
TypeId
|
|
Ipv4GlobalRouting::GetTypeId (void)
|
|
{
|
|
static TypeId tid = TypeId ("ns3::Ipv4GlobalRouting")
|
|
.SetParent<Object> ()
|
|
;
|
|
return tid;
|
|
}
|
|
|
|
Ipv4GlobalRouting::Ipv4GlobalRouting ()
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
}
|
|
|
|
void
|
|
Ipv4GlobalRouting::AddHostRouteTo (Ipv4Address dest,
|
|
Ipv4Address nextHop,
|
|
uint32_t interface)
|
|
{
|
|
NS_LOG_FUNCTION (dest << nextHop << interface);
|
|
Ipv4Route *route = new Ipv4Route ();
|
|
*route = Ipv4Route::CreateHostRouteTo (dest, nextHop, interface);
|
|
m_hostRoutes.push_back (route);
|
|
}
|
|
|
|
void
|
|
Ipv4GlobalRouting::AddHostRouteTo (Ipv4Address dest,
|
|
uint32_t interface)
|
|
{
|
|
NS_LOG_FUNCTION (dest << interface);
|
|
Ipv4Route *route = new Ipv4Route ();
|
|
*route = Ipv4Route::CreateHostRouteTo (dest, interface);
|
|
m_hostRoutes.push_back (route);
|
|
}
|
|
|
|
void
|
|
Ipv4GlobalRouting::AddNetworkRouteTo (Ipv4Address network,
|
|
Ipv4Mask networkMask,
|
|
Ipv4Address nextHop,
|
|
uint32_t interface)
|
|
{
|
|
NS_LOG_FUNCTION (network << networkMask << nextHop << interface);
|
|
Ipv4Route *route = new Ipv4Route ();
|
|
*route = Ipv4Route::CreateNetworkRouteTo (network,
|
|
networkMask,
|
|
nextHop,
|
|
interface);
|
|
m_networkRoutes.push_back (route);
|
|
}
|
|
|
|
void
|
|
Ipv4GlobalRouting::AddNetworkRouteTo (Ipv4Address network,
|
|
Ipv4Mask networkMask,
|
|
uint32_t interface)
|
|
{
|
|
NS_LOG_FUNCTION (network << networkMask << interface);
|
|
Ipv4Route *route = new Ipv4Route ();
|
|
*route = Ipv4Route::CreateNetworkRouteTo (network,
|
|
networkMask,
|
|
interface);
|
|
m_networkRoutes.push_back (route);
|
|
}
|
|
|
|
Ipv4Route *
|
|
Ipv4GlobalRouting::LookupGlobal (Ipv4Address dest)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
for (HostRoutesCI i = m_hostRoutes.begin ();
|
|
i != m_hostRoutes.end ();
|
|
i++)
|
|
{
|
|
NS_ASSERT ((*i)->IsHost ());
|
|
if ((*i)->GetDest ().IsEqual (dest))
|
|
{
|
|
NS_LOG_LOGIC ("Found global host route" << *i);
|
|
return (*i);
|
|
}
|
|
}
|
|
for (NetworkRoutesI j = m_networkRoutes.begin ();
|
|
j != m_networkRoutes.end ();
|
|
j++)
|
|
{
|
|
NS_ASSERT ((*j)->IsNetwork ());
|
|
Ipv4Mask mask = (*j)->GetDestNetworkMask ();
|
|
Ipv4Address entry = (*j)->GetDestNetwork ();
|
|
if (mask.IsMatch (dest, entry))
|
|
{
|
|
NS_LOG_LOGIC ("Found global network route" << *j);
|
|
return (*j);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint32_t
|
|
Ipv4GlobalRouting::GetNRoutes (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
uint32_t n = 0;
|
|
n += m_hostRoutes.size ();
|
|
n += m_networkRoutes.size ();
|
|
return n;
|
|
}
|
|
|
|
Ipv4Route *
|
|
Ipv4GlobalRouting::GetRoute (uint32_t index)
|
|
{
|
|
NS_LOG_FUNCTION (index);
|
|
if (index < m_hostRoutes.size ())
|
|
{
|
|
uint32_t tmp = 0;
|
|
for (HostRoutesCI i = m_hostRoutes.begin ();
|
|
i != m_hostRoutes.end ();
|
|
i++)
|
|
{
|
|
if (tmp == index)
|
|
{
|
|
return *i;
|
|
}
|
|
tmp++;
|
|
}
|
|
}
|
|
index -= m_hostRoutes.size ();
|
|
uint32_t tmp = 0;
|
|
for (NetworkRoutesI j = m_networkRoutes.begin ();
|
|
j != m_networkRoutes.end ();
|
|
j++)
|
|
{
|
|
if (tmp == index)
|
|
{
|
|
return *j;
|
|
}
|
|
tmp++;
|
|
}
|
|
NS_ASSERT (false);
|
|
// quiet compiler.
|
|
return 0;
|
|
}
|
|
void
|
|
Ipv4GlobalRouting::RemoveRoute (uint32_t index)
|
|
{
|
|
NS_LOG_FUNCTION (index);
|
|
if (index < m_hostRoutes.size ())
|
|
{
|
|
uint32_t tmp = 0;
|
|
for (HostRoutesI i = m_hostRoutes.begin ();
|
|
i != m_hostRoutes.end ();
|
|
i++)
|
|
{
|
|
if (tmp == index)
|
|
{
|
|
NS_LOG_LOGIC ("Removing route " << index << "; size = " << m_hostRoutes.size());
|
|
delete *i;
|
|
m_hostRoutes.erase (i);
|
|
NS_LOG_LOGIC ("Done removing host route " << index << "; host route remaining size = " << m_hostRoutes.size());
|
|
return;
|
|
}
|
|
tmp++;
|
|
}
|
|
}
|
|
index -= m_hostRoutes.size ();
|
|
uint32_t tmp = 0;
|
|
for (NetworkRoutesI j = m_networkRoutes.begin ();
|
|
j != m_networkRoutes.end ();
|
|
j++)
|
|
{
|
|
if (tmp == index)
|
|
{
|
|
NS_LOG_LOGIC ("Removing route " << index << "; size = " << m_networkRoutes.size());
|
|
delete *j;
|
|
m_networkRoutes.erase (j);
|
|
NS_LOG_LOGIC ("Done removing network route " << index << "; network route remaining size = " << m_networkRoutes.size());
|
|
return;
|
|
}
|
|
tmp++;
|
|
}
|
|
NS_ASSERT (false);
|
|
}
|
|
|
|
bool
|
|
Ipv4GlobalRouting::RequestRoute (
|
|
uint32_t interface,
|
|
Ipv4Header const &ipHeader,
|
|
Ptr<Packet> packet,
|
|
RouteReplyCallback routeReply)
|
|
{
|
|
NS_LOG_FUNCTION (this << interface << &ipHeader << packet << &routeReply);
|
|
|
|
NS_LOG_LOGIC ("source = " << ipHeader.GetSource ());
|
|
|
|
NS_LOG_LOGIC ("destination = " << ipHeader.GetDestination ());
|
|
|
|
if (ipHeader.GetDestination ().IsMulticast ())
|
|
{
|
|
NS_LOG_LOGIC ("Multicast destination-- returning false");
|
|
return false; // Let other routing protocols try to handle this
|
|
}
|
|
|
|
// This is a unicast packet. Check to see if we have a route for it.
|
|
//
|
|
NS_LOG_LOGIC ("Unicast destination- looking up");
|
|
Ipv4Route *route = LookupGlobal (ipHeader.GetDestination ());
|
|
if (route != 0)
|
|
{
|
|
routeReply (true, *route, packet, ipHeader);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false; // Let other routing protocols try to handle this
|
|
// route request.
|
|
}
|
|
}
|
|
|
|
bool
|
|
Ipv4GlobalRouting::RequestInterface (Ipv4Address destination, uint32_t& interface)
|
|
{
|
|
NS_LOG_FUNCTION (this << destination << &interface);
|
|
//
|
|
// First, see if this is a multicast packet we have a route for. If we
|
|
// have a route, then send the packet down each of the specified interfaces.
|
|
//
|
|
if (destination.IsMulticast ())
|
|
{
|
|
NS_LOG_LOGIC ("Multicast destination-- returning false");
|
|
return false; // Let other routing protocols try to handle this
|
|
}
|
|
//
|
|
// See if this is a unicast packet we have a route for.
|
|
//
|
|
NS_LOG_LOGIC ("Unicast destination- looking up");
|
|
Ipv4Route *route = LookupGlobal (destination);
|
|
if (route)
|
|
{
|
|
interface = route->GetInterface ();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void
|
|
Ipv4GlobalRouting::DoDispose (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
for (HostRoutesI i = m_hostRoutes.begin ();
|
|
i != m_hostRoutes.end ();
|
|
i = m_hostRoutes.erase (i))
|
|
{
|
|
delete (*i);
|
|
}
|
|
for (NetworkRoutesI j = m_networkRoutes.begin ();
|
|
j != m_networkRoutes.end ();
|
|
j = m_networkRoutes.erase (j))
|
|
{
|
|
delete (*j);
|
|
}
|
|
Ipv4RoutingProtocol::DoDispose ();
|
|
}
|
|
|
|
}//namespace ns3
|