void

SPFVertex::ClearVertexProcessed (void)

{

  for (uint32_t i = 0; i < this->GetNChildren (); i++)

  {

    this->GetChild (i)->ClearVertexProcessed ();

  }

  this->SetVertexProcessed (false);

}

      delete temp;

    }

  for (uint32_t j=0; j<m_extdatabase.size (); j++)

    {

      NS_LOG_LOGIC ("free ASexternalLSA");

      GlobalRoutingLSA* temp = m_extdatabase.at (j);

      Ptr<Ipv4GlobalRouting> grouting = rtr->GetRoutingProtocol ();

  for (uint32_t i = 0;i<m_lsdb->GetNumExtLSAs ();i++)

  {

    m_spfroot->ClearVertexProcessed ();

    GlobalRoutingLSA *extlsa = m_lsdb->GetExtLSA (i);

    NS_LOG_LOGIC ("Processing External LSA with id " << extlsa->GetLinkStateId ());

    ProcessASExternals (m_spfroot, extlsa);

  }

void

GlobalRouteManagerImpl::ProcessASExternals (SPFVertex* v, GlobalRoutingLSA* extlsa)

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_LOG_LOGIC ("Processing external for destination " << 

      extlsa->GetLinkStateId () <<

      ", for router "  << v->GetVertexId () << 

      ", advertised by " << extlsa->GetAdvertisingRouter ());

  if (v->GetVertexType () == SPFVertex::VertexRouter)

  {

    GlobalRoutingLSA *rlsa = v->GetLSA ();

    NS_LOG_LOGIC ("Processing router LSA with id " << rlsa->GetLinkStateId ());

      if ((rlsa->GetLinkStateId ()) == (extlsa->GetAdvertisingRouter ()))

      {

        NS_LOG_LOGIC ("Found advertising router to destination");

        SPFAddASExternal(extlsa,v);

      }

  }

  for (uint32_t i = 0; i < v->GetNChildren (); i++)

  {

    if (!v->GetChild (i)->IsVertexProcessed ())

    {

      NS_LOG_LOGIC ("Vertex's child " << i << " not yet processed, processing...");

      ProcessASExternals (v->GetChild (i), extlsa);

      v->GetChild (i)->SetVertexProcessed (true);

    }

  }

}

//

// Adding external routes to routing table - modeled after

// SPFAddIntraAddStub()

//

void

GlobalRouteManagerImpl::SPFAddASExternal (GlobalRoutingLSA *extlsa, SPFVertex *v)

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT_MSG (m_spfroot, 

                 "GlobalRouteManagerImpl::SPFAddASExternal (): Root pointer not set");

  // Two cases to consider: We are advertising the external ourselves

  // => No need to add anything

  // OR find best path to the advertising router

  if (v->GetVertexId () == m_spfroot->GetVertexId ())

  {

    NS_LOG_LOGIC ("External is on local host: " 

      << v->GetVertexId () << "; returning");

    return;

  }

  NS_LOG_LOGIC ("External is on remote host: " 

    << extlsa->GetAdvertisingRouter () << "; installing");

  Ipv4Address routerId = m_spfroot->GetVertexId ();

  NS_LOG_LOGIC ("Vertex ID = " << routerId);

  //

// We need to walk the list of nodes looking for the one that has the router

// ID corresponding to the root vertex.  This is the one we're going to write

// the routing information to.

//

  NodeList::Iterator i = NodeList::Begin (); 

  for (; i != NodeList::End (); i++)

  {

    Ptr<Node> node = *i;

//

// The router ID is accessible through the GlobalRouter interface, so we need

// to QI for that interface.  If there's no GlobalRouter interface, the node

// in question cannot be the router we want, so we continue.

// 

    Ptr<GlobalRouter> rtr = 

        node->GetObject<GlobalRouter> ();

    if (rtr == 0)

    {

      NS_LOG_LOGIC ("No GlobalRouter interface on node " << 

          node->GetId ());

      continue;

    }

//

// If the router ID of the current node is equal to the router ID of the 

// root of the SPF tree, then this node is the one for which we need to 

// write the routing tables.

//

    NS_LOG_LOGIC ("Considering router " << rtr->GetRouterId ());

    if (rtr->GetRouterId () == routerId)

    {

      NS_LOG_LOGIC ("Setting routes for node " << node->GetId ());

//

// Routing information is updated using the Ipv4 interface.  We need to QI

// for that interface.  If the node is acting as an IP version 4 router, it

// should absolutely have an Ipv4 interface.

//

      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();

      NS_ASSERT_MSG (ipv4, 

                     "GlobalRouteManagerImpl::SPFIntraAddRouter (): "

                         "QI for <Ipv4> interface failed");

//

// Get the Global Router Link State Advertisement from the vertex we're

// adding the routes to.  The LSA will have a number of attached Global Router

// Link Records corresponding to links off of that vertex / node.  We're going

// to be interested in the records corresponding to point-to-point links.

//

      NS_ASSERT_MSG (v->GetLSA (), 

                     "GlobalRouteManagerImpl::SPFIntraAddRouter (): "

                         "Expected valid LSA in SPFVertex* v");

      Ipv4Mask tempmask = extlsa->GetNetworkLSANetworkMask();

      Ipv4Address tempip = extlsa->GetLinkStateId ();

      tempip = tempip.CombineMask (tempmask);

      NS_LOG_LOGIC (" Node " << node->GetId () <<

          " add route to " << tempip <<

          " with mask " << tempmask <<

          " using next hop " << v->GetNextHop () <<

          " via interface " << v->GetOutgoingInterfaceId ());

//

// Here's why we did all of that work.  We're going to add a host route to the

// host address found in the m_linkData field of the point-to-point link

// record.  In the case of a point-to-point link, this is the local IP address

// of the node connected to the link.  Each of these point-to-point links

// will correspond to a local interface that has an IP address to which

// the node at the root of the SPF tree can send packets.  The vertex <v> 

// (corresponding to the node that has these links and interfaces) has 

// an m_nextHop address precalculated for us that is the address to which the

// root node should send packets to be forwarded to these IP addresses.

// Similarly, the vertex <v> has an m_rootOif (outbound interface index) to

// which the packets should be send for forwarding.

//

      Ptr<GlobalRouter> router = node->GetObject<GlobalRouter> ();

      if (router == 0)

      {

        continue;

      }

      Ptr<Ipv4GlobalRouting> gr = router->GetRoutingProtocol ();

      NS_ASSERT (gr);

      if (v->GetOutgoingInterfaceId () >= 0)

      {

        gr->AddASExternalRouteTo (tempip, tempmask, v->GetNextHop (), v->GetOutgoingInterfaceId ());

        NS_LOG_LOGIC ("Node " << node->GetId () <<

            " add network route to " << tempip <<

            " using next hop " << v->GetNextHop () <<

            " via interface " << v->GetOutgoingInterfaceId ());

      }

      else

      {

        NS_LOG_LOGIC ("Node " << node->GetId () <<

            " NOT able to add network route to " << tempip <<

            " using next hop " << v->GetNextHop () <<

            " since outgoing interface id is negative");

      }

      return;

    } // if

  } // for

}

#include <vector>

  void ClearVertexProcessed (void);

  GlobalRoutingLSA* GetExtLSA (uint32_t index) const;

  uint32_t GetNumExtLSAs () const;

  std::vector<GlobalRoutingLSA*> m_extdatabase;

  void ProcessASExternals (SPFVertex* v, GlobalRoutingLSA* extlsa);

  void SPFAddASExternal (GlobalRoutingLSA *extlsa, SPFVertex *v);

  else if (m_lsType == GlobalRoutingLSA::ASExternalLSAs)

    {

      os << " (GlobalRoutingLSA::ASExternalLSA)";

    }

  else if (m_lsType == GlobalRoutingLSA::ASExternalLSAs)

    {

      os << "---------- ASExternalLSA Link Record --------" << std::endl;

      os << "m_linkStateId = " << m_linkStateId << std::endl;

      os << "m_networkLSANetworkMask = " << m_networkLSANetworkMask << std::endl;

    }

  for (InjectedRoutesI k = m_injectedRoutes.begin ();

         k != m_injectedRoutes.end ();

         k = m_injectedRoutes.erase (k))

    {

      delete (*k);

    }

  //

  // Build injected route LSAs as external routes

  // RFC 2328, section 12.4.4

  //

  for (InjectedRoutesCI i = m_injectedRoutes.begin();

       i != m_injectedRoutes.end();

       i++)

    {

      GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;

      pLSA->SetLSType (GlobalRoutingLSA::ASExternalLSAs);

      pLSA->SetLinkStateId ((*i)->GetDestNetwork ());

      pLSA->SetAdvertisingRouter (m_routerId);

      pLSA->SetNetworkLSANetworkMask ((*i)->GetDestNetworkMask ());

      pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

      m_LSAs.push_back (pLSA); 

    }

void

GlobalRouter::InjectRoute (Ipv4Address network,

                                Ipv4Mask networkMask)

{

  NS_LOG_FUNCTION (network << networkMask);

  Ipv4RoutingTableEntry *route = new Ipv4RoutingTableEntry ();

//

// Interface number does not matter here, using 1.

//

  *route = Ipv4RoutingTableEntry::CreateNetworkRouteTo (network,

      networkMask,

      1);

  m_injectedRoutes.push_back (route);

}

Ipv4RoutingTableEntry *

GlobalRouter::GetInjectedRoute (uint32_t index)

{

  NS_LOG_FUNCTION (index);

  if (index < m_injectedRoutes.size ())

    {

      uint32_t tmp = 0;

      for (InjectedRoutesCI i = m_injectedRoutes.begin ();

           i != m_injectedRoutes.end ();

           i++)

        {

          if (tmp  == index)

            {

              return *i;

            }

          tmp++;

        }

     }

  NS_ASSERT (false);

  // quiet compiler.

  return 0;

}

uint32_t

GlobalRouter::GetNInjectedRoutes ()

{

  return m_injectedRoutes.size ();

}

#include "ns3/ipv4-routing-table-entry.h"

 * \param List of routing table entries of external routes to be injected.

 *

/**

  * @brief Inject a route to be circulated to other routers as an external

  * route

  *

  * Most of the public API for Ipv4GlobalRouting is for adding or deleting

  * routes that will be installed on this node.  However, this class also

  * stores routes that are intended to be propagated as AS-external-LSAs.

  *

  * @param network The Network to inject

  * @param networkMask The Network Mask to inject

  */

  void InjectRoute (Ipv4Address network,

                    Ipv4Mask networkMask);

/**

 * @brief Get the number of injected routes that have been added

 * to the routing table.

 * @return number of injected routes

 */

  uint32_t GetNInjectedRoutes (void);

/**

 * @brief Return the injected route indexed by i

 * @param i the index of the route

 * @return a pointer to that Ipv4RoutingTableEntry is returned

 *

 */

  Ipv4RoutingTableEntry *GetInjectedRoute (uint32_t i);

  typedef std::list<Ipv4RoutingTableEntry *> InjectedRoutes;

  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator InjectedRoutesCI;

  typedef std::list<Ipv4RoutingTableEntry *>::iterator InjectedRoutesI;

  InjectedRoutes m_injectedRoutes; // Routes we are exporting

void 

Ipv4GlobalRouting::AddASExternalRouteTo (Ipv4Address network, 

                                         Ipv4Mask networkMask,

                                         Ipv4Address nextHop,

                                         uint32_t interface)

{

  NS_LOG_FUNCTION (network << networkMask << nextHop);

  Ipv4RoutingTableEntry *route = new Ipv4RoutingTableEntry ();

  *route = Ipv4RoutingTableEntry::CreateNetworkRouteTo (network,

      networkMask,

      nextHop,

      interface);

  m_ASexternalRoutes.push_back (route);

}

  NS_LOG_LOGIC ("Looking for route for destination " << dest);

  if (found == false)

    {

      for (ASExternalRoutesI k = m_ASexternalRoutes.begin ();

           k != m_ASexternalRoutes.end ();

           k++)

        {

          Ipv4Mask mask = (*k)->GetDestNetworkMask ();

          Ipv4Address entry = (*k)->GetDestNetwork ();

          if (mask.IsMatch (dest, entry))

            {

              NS_LOG_LOGIC ("Found external route" << *k);

              route = (*k);

              found = true;

              break;

            }

        }

    }

  n += m_ASexternalRoutes.size ();

  index -= m_networkRoutes.size();

  tmp = 0;

  for (ASExternalRoutesI k = m_ASexternalRoutes.begin (); 

       k != m_ASexternalRoutes.end (); 

       k++) 

  {

    if (tmp == index)

    {

      return *k;

    }

    tmp++;

  }

  index -= m_networkRoutes.size ();

  tmp = 0;

  for (ASExternalRoutesI k = m_ASexternalRoutes.begin (); 

         k != m_ASexternalRoutes.end (); 

         k++) 

    {

      if (tmp == index)

      {

        NS_LOG_LOGIC ("Removing route " << index << "; size = " << m_ASexternalRoutes.size());

        delete *k;

        m_ASexternalRoutes.erase (k);

        NS_LOG_LOGIC ("Done removing network route " << index << "; network route remaining size = " << m_networkRoutes.size());

        return;

      }

      tmp++;

    }

  for (ASExternalRoutesI l = m_ASexternalRoutes.begin (); 

         l != m_ASexternalRoutes.end (); 

         l = m_ASexternalRoutes.erase (l)) 

    {

      delete (*l);

    }

 * \brief Add an external route to the global routing table.

 *

 * \param network The Ipv4Address network for this route.

 * \param networkMask The Ipv4Mask to extract the network.

 * \param nextHop The next hop Ipv4Address

 * \param interface The network interface index used to send packets to the

 * destination.

 */

  void AddASExternalRouteTo (Ipv4Address network,

                             Ipv4Mask networkMask,

                             Ipv4Address nextHop,

                             uint32_t interface);

/**

  typedef std::list<Ipv4RoutingTableEntry *> ASExternalRoutes;

  typedef std::list<Ipv4RoutingTableEntry *>::const_iterator ASExternalRoutesCI;

  typedef std::list<Ipv4RoutingTableEntry *>::iterator ASExternalRoutesI;