Attachment #312 for bug #114

View | Details | Raw Unified | Return to bug 114
Collapse All | Expand All




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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
 */

// Network topology
//
//        n0     n1  
//        |      | 
//       -----------
//       | bridge1 |
//       -----------
//           |    
//           n2   
//           |
//       -----------
//       | bridge2 |
//       -----------
//        |      | 
//        n3     n4  
//
// This example shows two broadcast domains, each interconnected by a bridge
// with a router node (n2) interconnecting the layer-2 broadcast domains
// 
// It is meant to mirror somewhat the csma-bridge example but adds another
// bridged link separated by a router.
// 
// - CBR/UDP flows from n0 to n1 and from n3 to n0
// - DropTail queues 
// - Global static routing
// - Tracing of queues and packet receptions to file "csma-bridge-one-hop.tr"

#include <iostream>
#include <fstream>

#include "ns3/simulator-module.h"
#include "ns3/node-module.h"
#include "ns3/core-module.h"
#include "ns3/helper-module.h"
#include "ns3/bridge-module.h"
#include "ns3/global-route-manager.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("CsmaBridgeOneHopExample");

int 
main (int argc, char *argv[])
{
  //
  // Users may find it convenient to turn on explicit debugging
  // for selected modules; the below lines suggest how to do this
  //
#if 0 
  LogComponentEnable ("CsmaBridgeOneHopExample", LOG_LEVEL_INFO);
#endif

  //
  // Make the random number generators generate reproducible results.
  //
  RandomVariable::UseGlobalSeed (1, 1, 2, 3, 5, 8);

  //
  // Allow the user to override any of the defaults and the above Bind() at
  // run-time, via command-line arguments
  //
  CommandLine cmd;
  cmd.Parse (argc, argv);

  //
  // Explicitly create the nodes required by the topology (shown above).
  //
  NS_LOG_INFO ("Create nodes.");

  Ptr<Node> n0 = CreateObject<Node> ();
  Ptr<Node> n1 = CreateObject<Node> ();
  Ptr<Node> n2 = CreateObject<Node> ();
  Ptr<Node> n3 = CreateObject<Node> ();
  Ptr<Node> n4 = CreateObject<Node> ();

  Ptr<Node> bridge1 = CreateObject<Node> ();
  Ptr<Node> bridge2 = CreateObject<Node> ();

  NS_LOG_INFO ("Build Topology");
  CsmaHelper csma;
  csma.SetChannelAttribute ("DataRate", DataRateValue (5000000));
  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));

  // Create the csma links, from each terminal to the bridge
  // This will create six network devices; we'll keep track separately
  // of the devices on and off the bridge respectively, for later configuration 
  NetDeviceContainer topLanDevices;
  NetDeviceContainer topBridgeDevices;

  // It is easier to iterate the nodes in C++ if we put them into a container
  NodeContainer topLan (n2, n0, n1);

  for (int i = 0; i < 3; i++)
    {
      NetDeviceContainer link = csma.Install (NodeContainer (topLan.Get (i), bridge1));
      topLanDevices.Add (link.Get (0));
      topBridgeDevices.Add (link.Get (1));
    }

  // Create the bridge netdevice, which will do the packet switching
  BridgeHelper bridge;
  bridge.Install (bridge1, topBridgeDevices);

  // Add internet stack to the topLan nodes
  InternetStackHelper internet;
  internet.Install (topLan);

  // Repeat for bottom bridged LAN
  NetDeviceContainer bottomLanDevices;
  NetDeviceContainer bottomBridgeDevices;
  NodeContainer bottomLan (n2, n3, n4);
  for (int i = 0; i < 3; i++)
    {
      NetDeviceContainer link = csma.Install (NodeContainer (bottomLan.Get (i), bridge2));
      bottomLanDevices.Add (link.Get (0));
      bottomBridgeDevices.Add (link.Get (1));
    }
  bridge.Install (bridge2, bottomBridgeDevices);
  internet.Install (NodeContainer (n3, n4));


  // We've got the "hardware" in place.  Now we need to add IP addresses.
  //
  NS_LOG_INFO ("Assign IP Addresses.");
  Ipv4AddressHelper ipv4;
  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
  ipv4.Assign (topLanDevices);
  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
  ipv4.Assign (bottomLanDevices);

  // Create router nodes, initialize routing database and set up the routing
  // tables in the nodes.
  GlobalRouteManager::PopulateRoutingTables ();

  //
  // Create an OnOff application to send UDP datagrams from node zero to node 1.
  //
  NS_LOG_INFO ("Create Applications.");
  uint16_t port = 9;   // Discard port (RFC 863)

  OnOffHelper onoff ("ns3::UdpSocketFactory", 
                     Address (InetSocketAddress (Ipv4Address ("10.1.1.3"), port)));
  onoff.SetAttribute ("OnTime", RandomVariableValue (ConstantVariable (1)));
  onoff.SetAttribute ("OffTime", RandomVariableValue (ConstantVariable (0)));

  ApplicationContainer app = onoff.Install (n0);
  // Start the application
  app.Start (Seconds (1.0));
  app.Stop (Seconds (10.0));

  // Create an optional packet sink to receive these packets
  PacketSinkHelper sink ("ns3::UdpSocketFactory",
                         Address (InetSocketAddress (Ipv4Address::GetAny (), port)));
  sink.Install (n1);

  // 
  // Create a similar flow from n3 to n0, starting at time 1.1 seconds
  //
  onoff.SetAttribute ("Remote", 
                      AddressValue (InetSocketAddress (Ipv4Address ("10.1.1.2"), port)));
  ApplicationContainer app2 = onoff.Install (n3);

  sink.Install (n0);

  app2.Start (Seconds (1.1));
  app2.Stop (Seconds (10.0));

  //
  // Configure tracing of all enqueue, dequeue, and NetDevice receive events.
  // Trace output will be sent to the file "csma-bridge-one-hop.tr"
  //
  NS_LOG_INFO ("Configure Tracing.");
  std::ofstream ascii;
  ascii.open ("csma-bridge-one-hop.tr");
  CsmaHelper::EnableAsciiAll (ascii);

  //
  // Also configure some tcpdump traces; each interface will be traced.
  // The output files will be named:
  //     csma-bridge.pcap-<nodeId>-<interfaceId>
  // and can be read by the "tcpdump -r" command (use "-tt" option to
  // display timestamps correctly)
  //
  CsmaHelper::EnablePcapAll ("csma-bridge-one-hop");

  //
  // Now, do the actual simulation.
  //
  NS_LOG_INFO ("Run Simulation.");
  Simulator::Run ();
  Simulator::Destroy ();
  NS_LOG_INFO ("Done.");
}

(-)a/examples/wscript (+4 lines)

Lines 27-32 def build(bld):	Link Here

    obj = bld.create_ns3_program('csma-bridge',

    obj = bld.create_ns3_program('csma-bridge',

                                 ['bridge', 'csma', 'internet-stack'])

                                 ['bridge', 'csma', 'internet-stack'])

    obj.source = 'csma-bridge.cc'

    obj.source = 'csma-bridge.cc'

    obj = bld.create_ns3_program('csma-bridge-one-hop',

                                 ['bridge', 'csma', 'internet-stack'])

    obj.source = 'csma-bridge-one-hop.cc'

    obj = bld.create_ns3_program('udp-echo',

    obj = bld.create_ns3_program('udp-echo',

                                 ['csma', 'internet-stack'])

                                 ['csma', 'internet-stack'])

(-)a/src/devices/bridge/bridge-net-device.cc (+6 lines)

Lines 305-310 BridgeNetDevice::IsPointToPoint (void) c	Link Here

305

  return false;

305

  return false;

306

307

308

bool

309

BridgeNetDevice::IsBridge (void) const

310

311

  return true;

312

313

308

314

309

bool

315

bool

310

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

316

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

(-)a/src/devices/bridge/bridge-net-device.h (+1 lines)

Lines 98-103 public:	Link Here

  virtual bool IsMulticast (void) const;

  virtual bool IsMulticast (void) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

100

  virtual bool IsPointToPoint (void) const;

100

  virtual bool IsPointToPoint (void) const;

101

  virtual bool IsBridge (void) const;

101

  virtual bool Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

102

  virtual bool Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

102

  virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

103

  virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

103

  virtual Ptr<Node> GetNode (void) const;

104

  virtual Ptr<Node> GetNode (void) const;

(-)a/src/devices/csma/csma-net-device.cc (+7 lines)

Lines 837-842 CsmaNetDevice::IsPointToPoint (void) con	Link Here

837

  return false;

837

  return false;

838

839

840

  bool

841

CsmaNetDevice::IsBridge (void) const

842

843

  NS_LOG_FUNCTION_NOARGS ();

844

  return false;

845

846

840

  bool

847

  bool

841

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

848

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

842

849

(-)a/src/devices/csma/csma-net-device.h (+6 lines)

Lines 351-356 public:	Link Here

351

  virtual bool IsPointToPoint (void) const;

351

  virtual bool IsPointToPoint (void) const;

352

353

/**

353

/**

354

   * Is this a bridge?

355

   * \returns false.

356

*/

357

  virtual bool IsBridge (void) const;

358

359

/**

354

   * Start sending a packet down the channel.

360

   * Start sending a packet down the channel.

355

*/

361

*/

356

  virtual bool Send (Ptr<Packet> packet, const Address& dest,

362

  virtual bool Send (Ptr<Packet> packet, const Address& dest,

(-)a/src/devices/emu/emu-net-device.cc (+6 lines)

Lines 882-887 EmuNetDevice::IsPointToPoint (void) cons	Link Here

882

  return false;

882

  return false;

883

884

885

bool

886

EmuNetDevice::IsBridge (void) const

887

888

  return false;

889

890

885

void

891

void

886

EmuNetDevice::SetPromiscReceiveCallback (PromiscReceiveCallback cb)

892

EmuNetDevice::SetPromiscReceiveCallback (PromiscReceiveCallback cb)

887

893

(-)a/src/devices/emu/emu-net-device.h (+6 lines)

Lines 164-169 public:	Link Here

164

   * \returns false.

164

   * \returns false.

165

*/

165

*/

166

  virtual bool IsPointToPoint (void) const;

166

  virtual bool IsPointToPoint (void) const;

167

168

/**

169

   * Is this a bridge?

170

   * \returns false.

171

*/

172

  virtual bool IsBridge (void) const;

167

173

168

  virtual bool Send(Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber);

174

  virtual bool Send(Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber);

169

175

(-)a/src/devices/point-to-point/point-to-point-net-device.cc (+6 lines)

Lines 392-397 PointToPointNetDevice::IsPointToPoint (v	Link Here

392

393

394

  bool

394

  bool

395

PointToPointNetDevice::IsBridge (void) const

396

397

  return false;

398

399

400

  bool

395

PointToPointNetDevice::Send(

401

PointToPointNetDevice::Send(

396

  Ptr<Packet> packet,

402

  Ptr<Packet> packet,

397

  const Address &dest,

403

  const Address &dest,

(-)a/src/devices/point-to-point/point-to-point-net-device.h (+1 lines)

Lines 252-257 public:	Link Here

252

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

252

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

253

254

  virtual bool IsPointToPoint (void) const;

254

  virtual bool IsPointToPoint (void) const;

255

  virtual bool IsBridge (void) const;

255

256

  virtual bool Send(Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber);

257

  virtual bool Send(Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber);

257

  virtual bool SendFrom(Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

258

  virtual bool SendFrom(Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

(-)a/src/devices/wifi/wifi-net-device.cc (+5 lines)

Lines 267-272 WifiNetDevice::IsPointToPoint (void) con	Link Here

267

  return false;

267

  return false;

268

269

bool

269

bool

270

WifiNetDevice::IsBridge (void) const

271

272

  return false;

273

274

bool

270

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

275

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

271

276

272

  NS_ASSERT (Mac48Address::IsMatchingType (dest));

277

  NS_ASSERT (Mac48Address::IsMatchingType (dest));

(-)a/src/devices/wifi/wifi-net-device.h (+1 lines)

Lines 94-99 public:	Link Here

  virtual bool IsMulticast (void) const;

  virtual bool IsMulticast (void) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

  virtual bool IsPointToPoint (void) const;

  virtual bool IsPointToPoint (void) const;

  virtual bool IsBridge (void) const;

  virtual bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

  virtual bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

  virtual Ptr<Node> GetNode (void) const;

  virtual Ptr<Node> GetNode (void) const;

  virtual void SetNode (Ptr<Node> node);

100

  virtual void SetNode (Ptr<Node> node);

(-)a/src/node/net-device.h (+9 lines)

Lines 184-189 public:	Link Here

184

  virtual Address GetMulticast (Ipv6Address addr) const = 0;

184

  virtual Address GetMulticast (Ipv6Address addr) const = 0;

185

186

/**

186

/**

187

   * \brief Return true if the net device is acting as a bridge.

188

189

   * \return value of m_isBridge flag

190

*/

191

  virtual bool IsBridge (void) const = 0;

192

193

/**

194

   * \brief Return true if the net device is on a point-to-point link.

195

187

   * \return value of m_isPointToPoint flag

196

   * \return value of m_isPointToPoint flag

188

*/

197

*/

189

  virtual bool IsPointToPoint (void) const = 0;

198

  virtual bool IsPointToPoint (void) const = 0;

(-)a/src/node/simple-net-device.cc (+7 lines)

Lines 163-168 SimpleNetDevice::IsPointToPoint (void) c	Link Here

163

164

  return false;

164

  return false;

165

166

167

bool

168

SimpleNetDevice::IsBridge (void) const

169

170

  return false;

171

172

166

bool

173

bool

167

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

174

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

168

175

(-)a/src/node/simple-net-device.h (+1 lines)

Lines 61-66 public:	Link Here

  virtual bool IsMulticast (void) const;

  virtual bool IsMulticast (void) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

  virtual Address GetMulticast (Ipv4Address multicastGroup) const;

  virtual bool IsPointToPoint (void) const;

  virtual bool IsPointToPoint (void) const;

  virtual bool IsBridge (void) const;

  virtual bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

  virtual bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);

  virtual bool SendFrom(Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

  virtual bool SendFrom(Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);

  virtual Ptr<Node> GetNode (void) const;

  virtual Ptr<Node> GetNode (void) const;





// Network topology
//
//         bridge1         The node named bridge1 (node 5 in the nodelist)
//   ------------------        has three CMSA net devices that are bridged
//   CSMA   CSMA   CSMA        together using a BridgeNetDevice.
//     |      |      |
//     |      |      |     The bridge node talks over three CSMA channels
//     |      |      |
//   CSMA   CSMA   CSMA    to three other CSMA net devices
//   ----   ----   ----    
//    n0     n1     n2     Node two acts as a router and talks to another
//                 ----        bridge that connects the remaining nodes.
//                 CSMA
//                   |
//    n3     n4      |
//   ----   ----     |
//   CSMA   CSMA     |
//     |      |      |
//     |      |      |
//     |      |      |
//   CSMA   CSMA   CSMA    The node named bridge2 (node 6 in the nodelist)
//   ------------------        has three CMSA net devices that are bridged
//        bridge2              together using a BridgeNetDevice.
//
// Or, more abstractly, recognizing that bridge 1 and bridge 2 are nodes 
// with three net devices:
//
//        n0     n1  
//        |      | 
//       -----------
//       | bridge1 | <- n5
//       -----------
//           |    
//         router    <- n2
//           |
//       -----------
//       | bridge2 | <- n6
//       -----------
//        |      | 
//        n3     n4  
//
// So, this example shows two broadcast domains, each interconnected by a bridge
// with a router node (n2) interconnecting the layer-2 broadcast domains
// 
// It is meant to mirror somewhat the csma-bridge example but adds another


  for (int i = 0; i < 3; i++)
    {
      // install a csma channel between the ith toplan node and the bridge node
      NetDeviceContainer link = csma.Install (NodeContainer (topLan.Get (i), bridge1));
      topLanDevices.Add (link.Get (0));
      topBridgeDevices.Add (link.Get (1));
    }

  //
  // Now, Create the bridge netdevice, which will do the packet switching.  The
  // bridge lives on the node bridge1 and bridges together the topBridgeDevices
  // which are the three CSMA net devices on the node in the diagram above.
  //
  BridgeHelper bridge;
  bridge.Install (bridge1, topBridgeDevices);


      bottomBridgeDevices.Add (link.Get (1));
    }
  bridge.Install (bridge2, bottomBridgeDevices);

  // Add internet stack to the bottomLan nodes
  internet.Install (NodeContainer (n3, n4));


  // We've got the "hardware" in place.  Now we need to add IP addresses.
  //
  NS_LOG_INFO ("Assign IP Addresses.");
  Ipv4AddressHelper ipv4;
  ipv4.SetBase ("10.1.1.0", "255.255.255.0");

  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
  ipv4.Assign (bottomLanDevices);

  // 
  // Create router nodes, initialize routing database and set up the routing
  // tables in the nodes.
  //
  NodeContainer routerNodes (n0, n1, n2, n3, n4);
  GlobalRouteManager::PopulateRoutingTables (routerNodes);

  //
  // Create an OnOff application to send UDP datagrams from node zero to node 1.




#define NS3_ABORT_H

#include "fatal-error.h"

#define NS_ABORT_MSG(msg)                                       \
  do {								\
    std::cerr << "file=" << __FILE__ <<                         \
      ", line=" << __LINE__ << ", abort, msg=\"" <<             \
      msg << "\"" << std::endl;                                 \
    int *a = 0;                                                 \
    *a = 0;							\
  } while (false)


#define NS_ABORT_IF(cond)					\
  do {								\




    m_ifIndex (0),
    m_mtu (0xffff)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_channel = CreateObject<BridgeChannel> ();
}


BridgeNetDevice::ForwardUnicast (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet,
                                 uint16_t protocol, Mac48Address src, Mac48Address dst)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_DEBUG ("LearningBridgeForward (incomingPort=" << incomingPort->GetName ()
                << ", packet=" << packet << ", protocol="<<protocol
                << ", src=" << src << ", dst=" << dst << ")");

BridgeNetDevice::ForwardBroadcast (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet,
                                        uint16_t protocol, Mac48Address src, Mac48Address dst)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_DEBUG ("LearningBridgeForward (incomingPort=" << incomingPort->GetName ()
                << ", packet=" << packet << ", protocol="<<protocol
                << ", src=" << src << ", dst=" << dst << ")");


void BridgeNetDevice::Learn (Mac48Address source, Ptr<NetDevice> port)
{
  NS_LOG_FUNCTION_NOARGS ();
  if (m_enableLearning)
    {
      LearnedState &state = m_learnState[source];


Ptr<NetDevice> BridgeNetDevice::GetLearnedState (Mac48Address source)
{
  NS_LOG_FUNCTION_NOARGS ();
  if (m_enableLearning)
    {
      Time now = Simulator::Now ();

  return NULL;
}

uint32_t
BridgeNetDevice::GetNBridgePorts (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_ports.size ();
}


Ptr<NetDevice>
BridgeNetDevice::GetBridgePort (uint32_t n) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_ports[n];
}

void 
BridgeNetDevice::AddBridgePort (Ptr<NetDevice> bridgePort)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_ASSERT (bridgePort != this);
  if (!Mac48Address::IsMatchingType (bridgePort->GetAddress ()))
    {

void 
BridgeNetDevice::SetName(const std::string name)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_name = name;
}

std::string 
BridgeNetDevice::GetName(void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_name;
}

void 
BridgeNetDevice::SetIfIndex(const uint32_t index)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_ifIndex = index;
}

uint32_t 
BridgeNetDevice::GetIfIndex(void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_ifIndex;
}

Ptr<Channel> 
BridgeNetDevice::GetChannel (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_channel;
}

Address 
BridgeNetDevice::GetAddress (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_address;
}

bool 
BridgeNetDevice::SetMtu (const uint16_t mtu)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_mtu = mtu;
  return true;
}

uint16_t 
BridgeNetDevice::GetMtu (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_mtu;
}


bool 
BridgeNetDevice::IsLinkUp (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


bool 
BridgeNetDevice::IsBroadcast (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


Address
BridgeNetDevice::GetBroadcast (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return Mac48Address ("ff:ff:ff:ff:ff:ff");
}

bool
BridgeNetDevice::IsMulticast (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


bool 
BridgeNetDevice::IsPointToPoint (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return false;
}

bool 
BridgeNetDevice::IsBridge (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


bool 
BridgeNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
{
  NS_LOG_FUNCTION_NOARGS ();
  for (std::vector< Ptr<NetDevice> >::iterator iter = m_ports.begin ();
         iter != m_ports.end (); iter++)
    {

bool 
BridgeNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
{
  NS_LOG_FUNCTION_NOARGS ();
  for (std::vector< Ptr<NetDevice> >::iterator iter = m_ports.begin ();
         iter != m_ports.end (); iter++)
    {

Ptr<Node> 
BridgeNetDevice::GetNode (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_node;
}


void 
BridgeNetDevice::SetNode (Ptr<Node> node)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_node = node;
}


bool 
BridgeNetDevice::NeedsArp (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


void 
BridgeNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_rxCallback = cb;
}

void 
BridgeNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_promiscRxCallback = cb;
}

bool
BridgeNetDevice::SupportsSendFrom () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}


void
BridgeNetDevice::DoDispose (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_node = 0;
  NetDevice::DoDispose ();
}

(-)a/src/devices/bridge/bridge-net-device.h (+4 lines)

Lines 82-87 public:	Link Here

*/

*/

  void AddBridgePort (Ptr<NetDevice> bridgePort);

  void AddBridgePort (Ptr<NetDevice> bridgePort);

  uint32_t GetNBridgePorts (void) const;

  Ptr<NetDevice> GetBridgePort (uint32_t n) const;

  // inherited from NetDevice base class.

  // inherited from NetDevice base class.

  virtual void SetName(const std::string name);

  virtual void SetName(const std::string name);

  virtual std::string GetName(void) const;

  virtual std::string GetName(void) const;




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c)
 *
 * 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 "bridge-helper.h"
#include "ns3/log.h"
#include "ns3/bridge-net-device.h"
#include "ns3/node.h"

NS_LOG_COMPONENT_DEFINE ("BridgeHelper");

namespace ns3 {

BridgeHelper::BridgeHelper ()
{
  NS_LOG_FUNCTION_NOARGS ();
  m_deviceFactory.SetTypeId ("ns3::BridgeNetDevice");
}

void 
BridgeHelper::SetDeviceAttribute (std::string n1, const AttributeValue &v1)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_deviceFactory.Set (n1, v1);
}

NetDeviceContainer
BridgeHelper::Install (Ptr<Node> node, NetDeviceContainer c)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_LOGIC ("**** Install bridge device on node " << node->GetId ());

  NetDeviceContainer devs;
  Ptr<BridgeNetDevice> dev = m_deviceFactory.Create<BridgeNetDevice> ();
  devs.Add (dev);


  for (NetDeviceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
    {
      NS_LOG_LOGIC ("**** Add BridgePort "<< *i);
      dev->AddBridgePort (*i);
    }
  return devs;




  Add (b);
  Add (c);
  Add (d);
}

NodeContainer::NodeContainer (const NodeContainer &a, const NodeContainer &b, 
                              const NodeContainer &c, const NodeContainer &d,
                              const NodeContainer &e)
{
  Add (a);
  Add (b);
  Add (c);
  Add (d);
  Add (e);
}

NodeContainer::Iterator 

(-)a/src/helper/node-container.h (+2 lines)

Lines 64-69 public:	Link Here

  NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c);

  NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c);

  NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c, const NodeContainer &d);

  NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c, const NodeContainer &d);

  NodeContainer (const NodeContainer &a, const NodeContainer &b, const NodeContainer &c, const NodeContainer &d,

                 const NodeContainer &e);

/**

/**

   * \returns an iterator to the start of the vector of node pointers.

   * \returns an iterator to the start of the vector of node pointers.





//
// In order to build the routing database, we need at least one of the nodes
// to participate as a router.  This is a convenience function that makes
// for selecting a subset of the nodes to participate; for now, we just make
// all nodes routers.  We do this by walking the list of nodes in the system
// and aggregating a Global Router Interface to each of the nodes.
//

{
  NS_LOG_FUNCTION_NOARGS ();
  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); i++)
    {
      Ptr<Node> node = *i;
      NS_LOG_LOGIC ("Adding GlobalRouter interface to node " << 
        node->GetId ());

      Ptr<GlobalRouter> globalRouter = CreateObject<GlobalRouter> ();
      node->AggregateObject (globalRouter);
    }
}

  void
GlobalRouteManagerImpl::SelectRouterNodes (NodeContainer c) 
{
  NS_LOG_FUNCTION_NOARGS ();
  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); i++)
    {
      Ptr<Node> node = *i;
      NS_LOG_LOGIC ("Adding GlobalRouter interface to node " << 

(-)a/src/routing/global-routing/global-route-manager-impl.h (+9 lines)

Lines 29-34	Link Here

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-address.h"

#include "ns3/node-container.h"

#include "global-router-interface.h"

#include "global-router-interface.h"

namespace ns3 {

namespace ns3 {

Lines 708-713 public:	Link Here

708

  virtual void SelectRouterNodes ();

709

  virtual void SelectRouterNodes ();

709

710

/**

711

/**

712

 * @brief Select which nodes in the system are to be router nodes and

713

 * aggregate the appropriate interfaces onto those nodes.

714

 * @internal

715

716

*/

717

  virtual void SelectRouterNodes (NodeContainer c);

718

719

/**

711

 * @brief Build the routing database by gathering Link State Advertisements

720

 * @brief Build the routing database by gathering Link State Advertisements

712

 * from each node exporting a GlobalRouter interface.

721

 * from each node exporting a GlobalRouter interface.

713

 * @internal

722

 * @internal




#include "ns3/assert.h"
#include "ns3/log.h"
#include "ns3/simulation-singleton.h"
#include "ns3/node-container.h"
#include "global-route-manager.h"
#include "global-route-manager-impl.h"


// ---------------------------------------------------------------------------

  void
GlobalRouteManager::PopulateRoutingTables (void) 
{
  SelectRouterNodes ();
  BuildGlobalRoutingDatabase ();

}

  void
GlobalRouteManager::PopulateRoutingTables (NodeContainer c) 
{
  SelectRouterNodes (c);
  BuildGlobalRoutingDatabase ();
  InitializeRoutes ();
}

  void
GlobalRouteManager::SelectRouterNodes (void) 
{
  SimulationSingleton<GlobalRouteManagerImpl>::Get ()->
    SelectRouterNodes ();
}

  void
GlobalRouteManager::SelectRouterNodes (NodeContainer c) 
{
  SimulationSingleton<GlobalRouteManagerImpl>::Get ()->
    SelectRouterNodes (c);
}

  void
GlobalRouteManager::BuildGlobalRoutingDatabase (void) 
{
  SimulationSingleton<GlobalRouteManagerImpl>::Get ()->
    BuildGlobalRoutingDatabase ();
}

  void
GlobalRouteManager::InitializeRoutes (void)
{
  SimulationSingleton<GlobalRouteManagerImpl>::Get ()->
    InitializeRoutes ();
}

  uint32_t
GlobalRouteManager::AllocateRouterId (void)
{
  static uint32_t routerId = 0;
  return routerId++;

(-)a/src/routing/global-routing/global-route-manager.h (-1 / +25 lines)

Lines 22-27	Link Here

#ifndef GLOBAL_ROUTE_MANAGER_H

#ifndef GLOBAL_ROUTE_MANAGER_H

#define GLOBAL_ROUTE_MANAGER_H

#define GLOBAL_ROUTE_MANAGER_H

#include "ns3/node-container.h"

namespace ns3 {

namespace ns3 {

/**

/**

Lines 40-46 public:	Link Here

public:

public:

/**

/**

 * @brief Build a routing database and initialize the routing tables of

 * @brief Build a routing database and initialize the routing tables of

 * the nodes in the simulation.

 * the nodes in the simulation.  Makes all nodes in the simulation into

 * routers.

 * All this function does is call  BuildGlobalRoutingDatabase () and

 * All this function does is call  BuildGlobalRoutingDatabase () and

 * InitializeRoutes ().

 * InitializeRoutes ().

Lines 49-54 public:	Link Here

 * @see InitializeRoutes ();

 * @see InitializeRoutes ();

*/

*/

  static void PopulateRoutingTables ();

  static void PopulateRoutingTables ();

/**

 * @brief Build a routing database and initialize the routing tables of

 * the nodes in the simulation.  Makes the nodes in the provided container

 * into routers.

 * All this function does is call  BuildGlobalRoutingDatabase () and

 * InitializeRoutes ().

 * @see BuildGlobalRoutingDatabase ();

 * @see InitializeRoutes ();

*/

  static void PopulateRoutingTables (NodeContainer c);

/**

/**

 * @brief Allocate a 32-bit router ID from monotonically increasing counter.

 * @brief Allocate a 32-bit router ID from monotonically increasing counter.

Lines 63-68 private:	Link Here

*/

*/

  static void SelectRouterNodes ();

  static void SelectRouterNodes ();

/**

 * @brief Select which nodes in the system are to be router nodes and

 * aggregate the appropriate interfaces onto those nodes.

 * @internal

*/

  static void SelectRouterNodes (NodeContainer c);

/**

/**

 * @brief Build the routing database by gathering Link State Advertisements

 * @brief Build the routing database by gathering Link State Advertisements





#include "ns3/log.h"
#include "ns3/assert.h"
#include "ns3/abort.h"
#include "ns3/channel.h"
#include "ns3/net-device.h"
#include "ns3/node.h"
#include "ns3/ipv4.h"
#include "ns3/bridge-net-device.h"
#include "global-router-interface.h"
#include <vector>

NS_LOG_COMPONENT_DEFINE ("GlobalRouter");


          return *i;
        }
    }
  NS_ASSERT_MSG(false, "GlobalRoutingLSA::GetAttachedRouter (): invalid index");
    "GlobalRoutingLSA::GetAttachedRouter (): invalid index");
  return Ipv4Address("0.0.0.0");
}


{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Node> node = GetObject<Node> ();
  NS_ABORT_MSG_UNLESS (node, "GlobalRouter::DiscoverLSAs (): GetObject for <Node> interface failed");
  NS_LOG_LOGIC ("For node " << node->GetId () );
    "GlobalRouter::DiscoverLSAs (): <Node> interface not set");

  ClearLSAs ();
//
// While building the router-LSA, keep a list of those NetDevices for
// which I am the designated router and need to later build a NetworkLSA
//
  std::list<Ptr<NetDevice> > listOfDRInterfaces;

//
// We're aggregated to a node.  We need to ask the node for a pointer to its
// Ipv4 interface.  This is where the information regarding the attached 
// interfaces lives.  If we're a router, we had better have an Ipv4 interface.
//
  Ptr<Ipv4> ipv4Local = node->GetObject<Ipv4> ();
  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::DiscoverLSAs (): GetObject for <Ipv4> interface failed");
    "GlobalRouter::DiscoverLSAs (): QI for <Ipv4> interface failed");
//
// Each node is a router and so originates a Router-LSA
//
  GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;
  pLSA->SetLSType (GlobalRoutingLSA::RouterLSA);
  pLSA->SetLinkStateId (m_routerId);
  pLSA->SetAdvertisingRouter (m_routerId);
  pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

//
// Ask the node for the number of net devices attached. This isn't necessarily 
// equal to the number of links to adjacent nodes (other routers) as the number
// of devices may include those for stub networks (e.g., ethernets, etc.) and 
// bridge devices also take up an "extra" net device.
//
  uint32_t numDevices = node->GetNDevices();
  NS_LOG_LOGIC ("numDevices = " << numDevices);

//
// There are two broad classes of devices:  bridges in combination with the
// devices they bridge and everything else.  We need to first discover all of
// the "everything else" class of devices.
//
// To do this, we wander through all of the devices on the node looking for
// bridge net devices.  We then add any net devices associated to a bridge
// to a list of bridged devices.  These devices will not be treated as stand-
// alone devices later.
//
  std::vector<Ptr<NetDevice> > bridgedDevices;

  NS_LOG_LOGIC ("*************************");

  NS_LOG_LOGIC ("numDevices = " << numDevices);
  for (uint32_t i = 0; i < numDevices; ++i)
    {
      Ptr<NetDevice> nd = node->GetDevice(i);
      if (nd->IsBridge ())
        {
          NS_LOG_LOGIC ("**** Net device " << nd << "is a bridge");
          //
          // XXX There is only one kind of bridge device so far.  We agreed to
          // assume that it is Gustavo's learning bridge until there is a need
          // to deal with another.  At that time, we'll have to break out a
          // bridge interface.
          //
          Ptr<BridgeNetDevice> bnd = nd->GetObject<BridgeNetDevice> ();
          NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              NS_LOG_LOGIC ("**** Net device " << bnd << "is a bridged device");
              bridgedDevices.push_back (bnd->GetBridgePort (j));
            }
        }
    }

  //
  // Iterate through the devices on the node and walk the channel to see what's
  // on the other side of the standalone devices..
  //
  for (uint32_t i = 0; i < numDevices; ++i)
    {
      Ptr<NetDevice> ndLocal = node->GetDevice(i);
      //
      // If the device in question is on our list of bridged devices, then we
      // just ignore it.  It will be dealt with correctly when we probe the 
      // bridge device it belongs to.  It is the case that the bridge code
      // assumes that bridged devices must not have IP interfaces, and so it 
      // may actually sufficient to perform the test for IP interface below, 
      // but that struck me as too indirect a condition.
      //
      for (uint32_t j = 0; j < bridgedDevices.size (); ++j)
        {
          if (ndLocal == bridgedDevices[j])
            {
              NS_LOG_LOGIC ("**** Skipping Bridged Device");

              continue;
            }
        }

      //
      // Check to see if the net device we just got has a corresponding IP 
      // interface (could be a pure L2 NetDevice).  
      //
      bool isIp = false;
      for (uint32_t i = 0; i < ipv4Local->GetNInterfaces (); ++i )
        {

              break;
            }
        }

      if (!isIp)
        {
          NS_LOG_LOGIC ("**** Net device " << ndLocal << "has no IP interface, skipping");
          continue;
        }

      if (ndLocal->IsBroadcast () && !ndLocal->IsPointToPoint () )
        {
          NS_LOG_LOGIC ("**** Broadcast link");
          GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;
//
// We need to determine whether we are on a transit or stub network
// If we find at least one more router on this channel, we are a transit
// network.  If we're the only router, we're on a stub.
//
// Now, we have to find the Ipv4 interface whose netdevice is the one we 
// just found.  This is still the IP on the local side of the channel.
// is a function to do this used down in the guts of the stack, but it's not 
// exported so we had to whip up an equivalent.
//
          uint32_t ifIndexLocal;
          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);
          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

          Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
          Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);
          NS_LOG_LOGIC ("Working with local address " << addrLocal);

          if (nDevices == 1)
            {
              // This is a stub broadcast interface
              NS_LOG_LOGIC("**** Router-LSA stub broadcast link");
              // XXX in future, need to consider if >1 includes other routers
              plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);
              // Link ID is IP network number of attached network

            }
          else
            {
              NS_LOG_LOGIC ("**** Router-LSA Broadcast link");
              // multiple routers on a broadcast interface
              // lowest IP address is designated router
              plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

        }
      else if (ndLocal->IsPointToPoint () )
        {
          NS_LOG_LOGIC ("**** Router-LSA Point-to-point device");
//
// Now, we have to find the Ipv4 interface whose netdevice is the one we 
// just found.  This is still the IP on the local side of the channel.  There 
// is a function to do this used down in the guts of the stack, but it's not 
// exported so we had to whip up an equivalent.
//
          uint32_t ifIndexLocal;
          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);
          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");
//
// Now that we have the Ipv4 interface index, we can get the address and mask
// we need.

            {
              continue;
            }
//
// Get the net device on the other side of the point-to-point channel.
//
          Ptr<NetDevice> ndRemote = GetAdjacent(ndLocal, ch);
//
// The adjacent net device is aggregated to a node.  We need to ask that net 
// device for its node, then ask that node for its Ipv4 interface.  Note a
// requirement that nodes on either side of a point-to-point link must have 
// internet stacks.
//
          Ptr<Node> nodeRemote = ndRemote->GetNode();
          Ptr<Ipv4> ipv4Remote = nodeRemote->GetObject<Ipv4> ();
          NS_ABORT_MSG_UNLESS (ipv4Remote, 
            "GlobalRouter::DiscoverLSAs (): GetObject for remote <Ipv4> failed");
//
// Per the OSPF spec, we're going to need the remote router ID, so we might as
// well get it now.
//
// While we're at it, further note the requirement that nodes on either side of
// a point-to-point link must participateg in global routing and therefore have
// a GlobalRouter interface aggregated.
//
          Ptr<GlobalRouter> srRemote = nodeRemote->GetObject<GlobalRouter> ();
          NS_ABORT_MSG_UNLESS(srRemote, 
            "GlobalRouter::DiscoverLSAs(): GetObject for remote <GlobalRouter> failed");

          Ipv4Address rtrIdRemote = srRemote->GetRouterId();
          NS_LOG_LOGIC ("Working with remote router " << rtrIdRemote);
//
// Now, just like we did above, we need to get the IP interface index for the 
// net device on the other end of the point-to-point channel.  We have yet another
// assumption that point to point devices are incompatible with bridges and that
// the remote device must have an associated ip interface.
//
          uint32_t ifIndexRemote;
          rc = FindIfIndexForDevice(nodeRemote, ndRemote, ifIndexRemote);
          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with remote device");
//
// Now that we have the Ipv4 interface, we can get the (remote) address and
// mask we need.

        {
          NS_ASSERT_MSG(0, "GlobalRouter::DiscoverLSAs (): unknown link type");
        }

    }
//
// The LSA goes on a list of LSAs in case we want to begin exporting other
// kinds of advertisements (than Router LSAs).
//
  m_LSAs.push_back (pLSA);
  NS_LOG_LOGIC (*pLSA);

// 
// Now, determine whether we need to build a NetworkLSA.  This is the case if
// we found at least one designated router.
//
  if (listOfDRInterfaces.size () > 0)
    {
      for (std::list<Ptr<NetDevice> >::iterator i = listOfDRInterfaces.begin ();
        i != listOfDRInterfaces.end (); i++)
        {
//
// Build one NetworkLSA for each interface that is a DR
//
          Ptr<NetDevice> ndLocal = *i;

          //
          // We are working with a list of net devices off of the local node
          // on which we found a designated router.  We assume there must be
          // an associated ipv4 interface index.
          //

          uint32_t ifIndexLocal;
          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);
          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

          Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
          Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);


          pLSA->SetAdvertisingRouter (m_routerId);
          pLSA->SetNetworkLSANetworkMask (maskLocal);
          pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);
//
// XXX Doesn't deal with bridging
//
// Build a list of AttachedRouters by walking the devices in the channel
// and, if we find an IPv4 interface associated with that device, we
// call it an attached router.  
//
          Ptr<Channel> ch = ndLocal->GetChannel();
          uint32_t nDevices = ch->GetNDevices();
          NS_ASSERT (nDevices);

              Ptr<NetDevice> tempNd = ch->GetDevice (i);
              NS_ASSERT (tempNd);
              Ptr<Node> tempNode = tempNd->GetNode ();
              uint32_t tempIfIndex;
              if (FindIfIndexForDevice (tempNode, tempNd, tempIfIndex))
                {

                  Ptr<Ipv4> tempIpv4 = tempNode->GetObject<Ipv4> ();
                  NS_ASSERT (tempIpv4);
                  Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);
                  pLSA->AddAttachedRouter (tempAddr);

                }
            }
          m_LSAs.push_back (pLSA);
          NS_LOG_LOGIC (*pLSA);

  return m_LSAs.size ();
}

//
// Given a node and an attached net device, we need to walk the channel to which
// the net device is attached and look for the lowest IP address on all of the
// devices attached to that channel.  This process is complicated by the fact 
// there may be bridge devices associated with any of the net devices attached
// to the channel.
//
  Ipv4Address
  GlobalRouter::FindDesignatedRouterForLink (Ptr<Node> node, Ptr<NetDevice> ndLocal) const
  Ptr<NetDevice> ndLocal) const
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_LOGIC("**** For node " << node->GetId () << " for net device " << ndLocal );

  uint32_t ifIndexLocal;
  bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);
  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

  Ptr<Ipv4> ipv4Local = GetObject<Ipv4> ();
  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::FindDesignatedRouterForLink(): GetObject for <Ipv4> interface failed"
                       " on node " << node->GetId ());

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

  Ptr<Channel> ch = ndLocal->GetChannel();
  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  NS_LOG_LOGIC("**** channel " << ch << " has " << nDevices << " net devices");

  //
  // We now have the channel associated with the net device in question.  We
  // need to iterate over all of the net devices attached to that channel.
  //

  Ipv4Address lowest = addrLocal;

  for (uint32_t i = 0; i < nDevices; i++)
    {
      Ptr<NetDevice> ndTemp = ch->GetDevice (i);
      NS_ASSERT_MSG (ndTemp, "GlobalRouter::FindDesignatedRouterForLink(): Null device attached to channel");

      if (ndTemp == ndLocal)
      Ptr<Ipv4> tempIpv4 = tempNode->GetObject<Ipv4> ();
      NS_ASSERT (tempIpv4);
      Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);
      if (tempAddr < addrLocal)
        {
          continue;
        }

      Ptr<Node> nodeTemp = ndTemp->GetNode ();

      NS_LOG_LOGIC("**** channel connects to node " << nodeTemp->GetId () << " with net device " << ndTemp);

      //
      // XXX doesn't admit the possibility of a bridge
      //
      // If the remote device doesn't have an ipv4 interface index associated 
      // with it, it cannot be a designated router.
      //
      uint32_t ifIndexTemp;
      bool rc = FindIfIndexForDevice(nodeTemp, ndTemp, ifIndexTemp);
      if (rc == false)
        {
          continue;
        }

      Ptr<Ipv4> ipv4Temp = nodeTemp->GetObject<Ipv4> ();
      NS_ASSERT_MSG (ipv4Temp, "GlobalRouter::FindDesignatedRouterForLink(): GetObject for <Ipv4> interface failed"
                     " on node " << node->GetId ());

      Ipv4Address addrTemp = ipv4Temp->GetAddress(ifIndexTemp);

      NS_LOG_LOGIC("**** net device " << ndTemp << " has Ipv4Address " << addrTemp);
      if (addrTemp < addrLocal)
        {
          addrLocal = addrTemp;
        }
    }
  return addrLocal;

}

//
// Given a node and a net device, find an IPV4 interface index that corresponds
// to that net device.  This function may fail for various reasons.  If a node
// does not have an internet stack (for example if it is a bridge) we won't have
// an IPv4 at all.  If the node does have a stack, but the net device in question
// is bridged, there will not be an interface associated directly with the device.
//
  bool
GlobalRouter::FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_LOGIC("For node " << node->GetId () << " for net device " << nd );

  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
  if (ipv4 == 0)
    {
      NS_LOG_LOGIC ("**** No Ipv4 interface on node " << node->GetId ());
      return false;
    }

  for (uint32_t i = 0; i < ipv4->GetNInterfaces(); ++i )
    {
      if (ipv4->GetNetDevice(i) == nd) 
        {
          NS_LOG_LOGIC ("**** Device " << nd << " has associated ipv4 index " << i);
          index = i;
          return true;
        }
    }

          NS_LOG_LOGIC ("**** Device " << nd << " has no associated ipv4 index");
  return false;
}

} // namespace ns3

(-)a/src/routing/global-routing/global-router-interface.h (-1 / +1 lines)

Lines 639-645 private:	Link Here

639

  void ClearLSAs (void);

639

  void ClearLSAs (void);

640

641

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

641

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

642

  uint32_t FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd) const;

642

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

643

  Ipv4Address FindDesignatedRouterForLink (Ptr<Node> node,

643

  Ipv4Address FindDesignatedRouterForLink (Ptr<Node> node,

644

    Ptr<NetDevice> ndLocal) const;

644

    Ptr<NetDevice> ndLocal) const;

645

(-)a/examples/csma-bridge-one-hop.cc (-1 / +2 lines)

Lines 176-182 main (int argc, char *argv[])	Link Here

176

177

//

177

//

178

  // Create router nodes, initialize routing database and set up the routing

178

  // Create router nodes, initialize routing database and set up the routing

179

  // tables in the nodes.

179

  // tables in the nodes.  We excuse the bridge nodes from having to serve as

180

  // routers, since they don't even have internet stacks on them.

180

//

181

//

181

  NodeContainer routerNodes (n0, n1, n2, n3, n4);

182

  NodeContainer routerNodes (n0, n1, n2, n3, n4);

182

  GlobalRouteManager::PopulateRoutingTables (routerNodes);

183

  GlobalRouteManager::PopulateRoutingTables (routerNodes);




// bridge devices also take up an "extra" net device.
//
  uint32_t numDevices = node->GetNDevices();
  NS_LOG_LOGIC ("*************************");
  NS_LOG_LOGIC ("numDevices = " << numDevices);

//

// the "everything else" class of devices.
//
// To do this, we wander through all of the devices on the node looking for
// bridge net devices.  We then add any net devices associated with each bridge
// to a list of bridged devices.  These devices will be treated as a special
// case later.
//
  std::vector<Ptr<NetDevice> > bridgedDevices;

  NS_LOG_LOGIC ("*************************");

  NS_LOG_LOGIC ("numDevices = " << numDevices);
  for (uint32_t i = 0; i < numDevices; ++i)
    {
      Ptr<NetDevice> nd = node->GetDevice(i);

      if (nd->IsBridge ())
        {
          NS_LOG_LOGIC ("**** Net device " << nd << "is a bridge");


      //
      // Check to see if the net device we just got has a corresponding IP 
      // interface (could be a pure L2 NetDevice that is not a bridge).  
      //
      bool isIp = false;
      for (uint32_t i = 0; i < ipv4Local->GetNInterfaces (); ++i )

          continue;
        }

//
// We have a net device that we need to check out.  If it suports broadcast and
// is not a point-point link, then it will be either a stub network or a transit
// network depending on the number of routers.
//
      if (ndLocal->IsBroadcast () && !ndLocal->IsPointToPoint () )
        {
          NS_LOG_LOGIC ("**** Broadcast link");

          NS_LOG_LOGIC ("Working with local address " << addrLocal);
          uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);
//
// Check to see if the net device is connected to a channel/network that has
// another router on it.  If there is no other router on the link (but us) then
// this is a stub network.  If we find another router, then what we have here
// is a transit network.
//
          if (AnotherRouterOnLink (ndLocal) == false)
          uint32_t nDevices = ch->GetNDevices();
          if (nDevices == 1)
            {
              //
              // This is a net device connected to a stub network
              //
              NS_LOG_LOGIC("**** Router-LSA Stub Network");
              plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);
              // 
              // According to OSPF, the Link ID is the IP network number of 
              // the attached network.
              //
              plr->SetLinkId (addrLocal.CombineMask(maskLocal));
              //
              // and the Link Data is the network mask; converted to Ipv4Address
              //
              Ipv4Address maskLocalAddr;
              maskLocalAddr.Set(maskLocal.Get ());
              plr->SetLinkData (maskLocalAddr);

            }
          else
            {
              //
              // We have multiple routers on a broadcast interface, so this is
              // a transit network.
              //
              NS_LOG_LOGIC ("**** Router-LSA Transit Network");
              plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);
              // 
              // By definition, the router with the lowest IP address is the
              // designated router for the network.  OSPF says that the Link ID
              // gets the IP interface address of the designated router in this 
              // case.
              //
              Ipv4Address desigRtr = FindDesignatedRouterForLink (ndLocal);
              if (desigRtr == addrLocal) 
                {
                  listOfDRInterfaces.push_back (ndLocal);
                  NS_LOG_LOGIC (node->GetId () << " is a DR");
                }
              plr->SetLinkId (desigRtr);
              //
              // OSPF says that the Link Data is this router's own IP address.
              //
              plr->SetLinkData (addrLocal);
              plr->SetMetric (metricLocal);
              pLSA->AddLinkRecord (plr);

// kinds of advertisements (than Router LSAs).
//
  m_LSAs.push_back (pLSA);
  NS_LOG_LOGIC ("========== Link State Advertisement for node " << node->GetId () << " ==========");
  NS_LOG_LOGIC (*pLSA);

// 

//
  if (listOfDRInterfaces.size () > 0)
    {
      NS_LOG_LOGIC ("Build Network LSA");
      for (std::list<Ptr<NetDevice> >::iterator i = listOfDRInterfaces.begin ();
        i != listOfDRInterfaces.end (); i++)
        {
//
// Build one NetworkLSA for each net device talking to a netwok that we are the 
// designated router for.
//
          Ptr<NetDevice> ndLocal = *i;

          //
          // We are working with a list of net devices off of the local node
          // on which we found a designated router.  We assume there must be
          // an associated ipv4 interface index.
          //

          uint32_t ifIndexLocal;
          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);

          pLSA->SetNetworkLSANetworkMask (maskLocal);
          pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);
//
// XXX Doesn't deal with bridging
//
// Build a list of AttachedRouters by walking the devices in the channel
// and, if we find a node with a GlobalRouter interface and an IPv4 
// interface associated with that device, we call it an attached router.  
//
          Ptr<Channel> ch = ndLocal->GetChannel();
          uint32_t nDevices = ch->GetNDevices();

              Ptr<NetDevice> tempNd = ch->GetDevice (i);
              NS_ASSERT (tempNd);
              Ptr<Node> tempNode = tempNd->GetNode ();
//
// Does the node in question have a GlobalRouter interface?  If not it can
// hardly be considered an attached router.
//
              Ptr<GlobalRouter> rtr = tempNode->GetObject<GlobalRouter> ();
              if (rtr == 0)
                { 
                  continue;
                }

//
// Does the attached node have an ipv4 interface for the device we're probing?
// If not, it can't play router.
//
              uint32_t tempIfIndex;
              if (FindIfIndexForDevice (tempNode, tempNd, tempIfIndex))
                {

                  Ptr<Ipv4> tempIpv4 = tempNode->GetObject<Ipv4> ();
                  NS_ASSERT (tempIpv4);
                  Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);
                  pLSA->AddAttachedRouter (tempAddr);

                }
            }
          m_LSAs.push_back (pLSA);

}

//
// Given a local net device, we need to walk the channel to which the net device is
// attached and look for nodes with GlobalRouter interfaces on them (one of them 
// will be us).  Of these, the router with the lowest IP address on the net device 
// connecting to the channel becomes the designated router for the link.
// to the channel.
//
  Ipv4Address
GlobalRouter::FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_LOGIC("**** For node " << node->GetId () << " for net device " << ndLocal );

  uint32_t ifIndexLocal;
  bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);
  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

  Ptr<Ipv4> ipv4Local = GetObject<Ipv4> ();
  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::FindDesignatedRouterForLink(): GetObject for <Ipv4> interface failed"
                       " on node " << node->GetId ());

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

  Ptr<Channel> ch = ndLocal->GetChannel();
  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  Ipv4Address addr ("255.255.255.255");

  for (uint32_t i = 0; i < nDevices; i++)
    {
      Ptr<NetDevice> currentNd = ch->GetDevice (i);
      NS_ASSERT (currentNd);

      Ptr<Node> currentNode = currentNd->GetNode ();
      NS_ASSERT (currentNode);
      //
      // We require a designated router to have a GlobalRouter interface and
      // an internet stack that includes the Ipv4 interface.
      //
      Ptr<GlobalRouter> rtr = currentNode->GetObject<GlobalRouter> ();
      Ptr<Ipv4> ipv4 = currentNode->GetObject<Ipv4> ();
      if (rtr == 0 || ipv4 == 0 )
        {
          continue;
        }

      //
      // This node could be a designated router, so we can check and see if
      // it has a lower IP address than the one we have.  In order to have
      // an IP address, it needs to have an interface index.  If it doesen't
      // have an interface index directly, it's probably part of a bridge
      // net device XXX which is not yet handled.
      //
      uint32_t currentIfIndex;
      bool rc = FindIfIndexForDevice(currentNode, currentNd, currentIfIndex);
      if (rc == false)
        {
          continue;
        }

      //
      // Okay, get the IP address corresponding to the interface we're 
      // examining and if it's the lowest so far, remember it.
      //
      Ipv4Address currentAddr = ipv4->GetAddress(currentIfIndex);

      if (currentAddr < addr)
        {
          addr = currentAddr;
        }
    }

  //
  // Return the lowest IP address found, which will become the designated router
  // for the link.
  //
  NS_ASSERT_MSG (addr.IsBroadcast() == false, "GlobalRouter::FindDesignatedRouterForLink(): Bogus address");
  return addr;
}

//
// Given a node and an attached net device, take a look off in the channel to 
// which the net device is attached and look for a node on the other side
// that has a GlobalRouter interface aggregated.
//
  bool
GlobalRouter::AnotherRouterOnLink (Ptr<NetDevice> nd) const
{
  NS_LOG_FUNCTION_NOARGS ();

  Ptr<Channel> ch = nd->GetChannel();
  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  for (uint32_t i = 0; i < nDevices; i++)
    {
      Ptr<NetDevice> ndTemp = ch->GetDevice (i);
      NS_ASSERT (ndTemp);

      if (ndTemp == nd)
        {
          continue;
        }

      Ptr<Node> nodeTemp = ndTemp->GetNode ();
      NS_ASSERT (nodeTemp);

      Ptr<GlobalRouter> rtr = nodeTemp->GetObject<GlobalRouter> ();
      if (rtr)
      //
      // XXX doesn't admit the possibility of a bridge
      //
      // If the remote device doesn't have an ipv4 interface index associated 
      // with it, it cannot be a designated router.
      //
      uint32_t ifIndexTemp;
      bool rc = FindIfIndexForDevice(nodeTemp, ndTemp, ifIndexTemp);
      if (rc == false)
        {
          return true;
        }

      Ptr<Ipv4> ipv4Temp = nodeTemp->GetObject<Ipv4> ();
      NS_ASSERT_MSG (ipv4Temp, "GlobalRouter::FindDesignatedRouterForLink(): GetObject for <Ipv4> interface failed"
                     " on node " << node->GetId ());

      Ipv4Address addrTemp = ipv4Temp->GetAddress(ifIndexTemp);

      NS_LOG_LOGIC("**** net device " << ndTemp << " has Ipv4Address " << addrTemp);
      if (addrTemp < addrLocal)
        {
          addrLocal = addrTemp;
        }
    }
  return false;
}

  uint32_t 

(-)a/src/routing/global-routing/global-router-interface.h (-2 / +2 lines)

Lines 640-647 private:	Link Here

640

641

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

641

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

642

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

642

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

643

  Ipv4Address FindDesignatedRouterForLink (Ptr<Node> node,

643

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

644

    Ptr<NetDevice> ndLocal) const;

644

  bool AnotherRouterOnLink (Ptr<NetDevice> nd) const;

645

646

  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t;

646

  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t;

647

  ListOfLSAs_t m_LSAs;

647

  ListOfLSAs_t m_LSAs;




{
  NS_LOG_FUNCTION_NOARGS ();
//
// Walk the list of nodes looking for the GlobalRouter Interface.  Nodes with
// global router interfaces are, not too surprisingly, our routers.
//
  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); i++)
    {
      Ptr<Node> node = *i;

      Ptr<GlobalRouter> rtr = node->GetObject<GlobalRouter> ();
        node->GetObject<GlobalRouter> ();
//      
// Ignore nodes that aren't participating in routing.
//

(-)a/src/routing/global-routing/global-router-interface.cc (-328 / +367 lines)

Lines 26-31	Link Here

#include "ns3/node.h"

#include "ns3/node.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4.h"

#include "ns3/bridge-net-device.h"

#include "ns3/bridge-net-device.h"

#include "ns3/net-device-container.h"

#include "global-router-interface.h"

#include "global-router-interface.h"

#include <vector>

#include <vector>

Lines 489-496 GlobalRouter::GetRouterId (void) const	Link Here

489

490

491

//

492

//

492

// Go out and discover any adjacent routers and build the Link State

493

// DiscoverLSAs is called on all nodes in the system that have a GlobalRouter

493

// Advertisements that reflect them and their associated networks.

494

// interface aggregated.  We need to go out and discover any adjacent routers

495

// and build the Link State Advertisements that reflect them and their associated

496

// networks.

494

//

497

//

495

  uint32_t

498

  uint32_t

496

GlobalRouter::DiscoverLSAs (void)

499

GlobalRouter::DiscoverLSAs (void)

Lines 501-573 GlobalRouter::DiscoverLSAs (void)	Link Here

501

  NS_LOG_LOGIC ("For node " << node->GetId () );

504

  NS_LOG_LOGIC ("For node " << node->GetId () );

502

505

503

  ClearLSAs ();

506

  ClearLSAs ();

504

//

505

// While building the router-LSA, keep a list of those NetDevices for

506

// which I am the designated router and need to later build a NetworkLSA

507

//

508

  std::list<Ptr<NetDevice> > listOfDRInterfaces;

509

507

510

//

508

//

511

// We're aggregated to a node.  We need to ask the node for a pointer to its

509

  // While building the Router-LSA, keep a list of those NetDevices for

512

// Ipv4 interface.  This is where the information regarding the attached

510

  // which the current node is the designated router and we will later build

513

// interfaces lives.  If we're a router, we had better have an Ipv4 interface.

511

  // a NetworkLSA for.

514

//

512

//

513

  NetDeviceContainer c;

514

515

//

516

  // We're aggregated to a node.  We need to ask the node for a pointer to its

517

  // Ipv4 interface.  This is where the information regarding the attached

518

  // interfaces lives.  If we're a router, we had better have an Ipv4 interface.

519

//

515

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

520

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

516

  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::DiscoverLSAs (): GetObject for <Ipv4> interface failed");

521

  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::DiscoverLSAs (): GetObject for <Ipv4> interface failed");

517

//

522

518

// Each node is a router and so originates a Router-LSA

523

//

519

//

524

  // Every router node originates a Router-LSA

525

//

520

  GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;

526

  GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;

521

  pLSA->SetLSType (GlobalRoutingLSA::RouterLSA);

527

  pLSA->SetLSType (GlobalRoutingLSA::RouterLSA);

522

  pLSA->SetLinkStateId (m_routerId);

528

  pLSA->SetLinkStateId (m_routerId);

523

  pLSA->SetAdvertisingRouter (m_routerId);

529

  pLSA->SetAdvertisingRouter (m_routerId);

524

  pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

530

  pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

525

531

526

//

532

//

527

// Ask the node for the number of net devices attached. This isn't necessarily

533

  // Ask the node for the number of net devices attached. This isn't necessarily

528

// equal to the number of links to adjacent nodes (other routers) as the number

534

  // equal to the number of links to adjacent nodes (other routers) as the number

529

// of devices may include those for stub networks (e.g., ethernets, etc.) and

535

  // of devices may include those for stub networks (e.g., ethernets, etc.) and

530

// bridge devices also take up an "extra" net device.

536

  // bridge devices also take up an "extra" net device.

531

//

537

//

532

  uint32_t numDevices = node->GetNDevices();

538

  uint32_t numDevices = node->GetNDevices();

533

  NS_LOG_LOGIC ("*************************");

534

  NS_LOG_LOGIC ("numDevices = " << numDevices);

535

536

//

537

// There are two broad classes of devices:  bridges in combination with the

538

// devices they bridge and everything else.  We need to first discover all of

539

// the "everything else" class of devices.

540

//

541

// To do this, we wander through all of the devices on the node looking for

542

// bridge net devices.  We then add any net devices associated with each bridge

543

// to a list of bridged devices.  These devices will be treated as a special

544

// case later.

545

//

546

  std::vector<Ptr<NetDevice> > bridgedDevices;

547

548

  for (uint32_t i = 0; i < numDevices; ++i)

549

550

      Ptr<NetDevice> nd = node->GetDevice(i);

551

552

      if (nd->IsBridge ())

553

554

          NS_LOG_LOGIC ("**** Net device " << nd << "is a bridge");

555

//

556

          // XXX There is only one kind of bridge device so far.  We agreed to

557

          // assume that it is Gustavo's learning bridge until there is a need

558

          // to deal with another.  At that time, we'll have to break out a

559

          // bridge interface.

560

//

561

          Ptr<BridgeNetDevice> bnd = nd->GetObject<BridgeNetDevice> ();

562

          NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

563

564

          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)

565

566

              NS_LOG_LOGIC ("**** Net device " << bnd << "is a bridged device");

567

              bridgedDevices.push_back (bnd->GetBridgePort (j));

568

569

570

571

539

572

//

540

//

573

  // Iterate through the devices on the node and walk the channel to see what's

541

  // Iterate through the devices on the node and walk the channel to see what's

Lines 576-602 GlobalRouter::DiscoverLSAs (void)	Link Here

576

  for (uint32_t i = 0; i < numDevices; ++i)

544

  for (uint32_t i = 0; i < numDevices; ++i)

577

545

578

      Ptr<NetDevice> ndLocal = node->GetDevice(i);

546

      Ptr<NetDevice> ndLocal = node->GetDevice(i);

579

//

580

      // If the device in question is on our list of bridged devices, then we

581

      // just ignore it.  It will be dealt with correctly when we probe the

582

      // bridge device it belongs to.  It is the case that the bridge code

583

      // assumes that bridged devices must not have IP interfaces, and so it

584

      // may actually sufficient to perform the test for IP interface below,

585

      // but that struck me as too indirect a condition.

586

//

587

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

588

589

          if (ndLocal == bridgedDevices[j])

590

591

              NS_LOG_LOGIC ("**** Skipping Bridged Device");

592

593

              continue;

594

595

596

547

597

//

548

//

598

      // Check to see if the net device we just got has a corresponding IP

549

      // Check to see if the net device we just got has a corresponding IP

599

      // interface (could be a pure L2 NetDevice that is not a bridge).

550

      // interface (could be a pure L2 NetDevice).

600

//

551

//

601

      bool isIp = false;

552

      bool isIp = false;

602

      for (uint32_t i = 0; i < ipv4Local->GetNInterfaces (); ++i )

553

      for (uint32_t i = 0; i < ipv4Local->GetNInterfaces (); ++i )

Lines 614-883 GlobalRouter::DiscoverLSAs (void)	Link Here

614

          continue;

565

          continue;

615

566

616

567

617

//

568

//

618

// We have a net device that we need to check out.  If it suports broadcast and

569

      // We have a net device that we need to check out.  If it suports

619

// is not a point-point link, then it will be either a stub network or a transit

570

      // broadcast and is not a point-point link, then it will be either a stub

620

// network depending on the number of routers.

571

      // network or a transit network depending on the number of routers on

621

//

572

      // the segment.  We add the appropriate link record to the LSA.

573

//

574

      // If the device is a point to point link, we treat it separately.  In

575

      // that case, there always two link records added.

576

//

622

      if (ndLocal->IsBroadcast () && !ndLocal->IsPointToPoint () )

577

      if (ndLocal->IsBroadcast () && !ndLocal->IsPointToPoint () )

623

578

624

          NS_LOG_LOGIC ("**** Broadcast link");

579

          NS_LOG_LOGIC ("**** Broadcast link");

625

          GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;

580

          ProcessBroadcastLink (ndLocal, pLSA, c);

626

//

627

// We need to determine whether we are on a transit or stub network

628

// If we find at least one more router on this channel, we are a transit

629

// network.  If we're the only router, we're on a stub.

630

//

631

// Now, we have to find the Ipv4 interface whose netdevice is the one we

632

// just found.  This is still the IP on the local side of the channel.

633

//

634

          uint32_t ifIndexLocal;

635

          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);

636

          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

637

638

          Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

639

          Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

640

          NS_LOG_LOGIC ("Working with local address " << addrLocal);

641

          uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);

642

//

643

// Check to see if the net device is connected to a channel/network that has

644

// another router on it.  If there is no other router on the link (but us) then

645

// this is a stub network.  If we find another router, then what we have here

646

// is a transit network.

647

//

648

          if (AnotherRouterOnLink (ndLocal) == false)

649

650

//

651

              // This is a net device connected to a stub network

652

//

653

              NS_LOG_LOGIC("**** Router-LSA Stub Network");

654

              plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

655

//

656

              // According to OSPF, the Link ID is the IP network number of

657

              // the attached network.

658

//

659

              plr->SetLinkId (addrLocal.CombineMask(maskLocal));

660

//

661

              // and the Link Data is the network mask; converted to Ipv4Address

662

//

663

              Ipv4Address maskLocalAddr;

664

              maskLocalAddr.Set(maskLocal.Get ());

665

              plr->SetLinkData (maskLocalAddr);

666

              plr->SetMetric (metricLocal);

667

              pLSA->AddLinkRecord(plr);

668

              plr = 0;

669

              continue;

670

671

          else

672

673

//

674

              // We have multiple routers on a broadcast interface, so this is

675

              // a transit network.

676

//

677

              NS_LOG_LOGIC ("**** Router-LSA Transit Network");

678

              plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

679

//

680

              // By definition, the router with the lowest IP address is the

681

              // designated router for the network.  OSPF says that the Link ID

682

              // gets the IP interface address of the designated router in this

683

              // case.

684

//

685

              Ipv4Address desigRtr = FindDesignatedRouterForLink (ndLocal);

686

              if (desigRtr == addrLocal)

687

688

                  listOfDRInterfaces.push_back (ndLocal);

689

                  NS_LOG_LOGIC (node->GetId () << " is a DR");

690

691

              plr->SetLinkId (desigRtr);

692

//

693

              // OSPF says that the Link Data is this router's own IP address.

694

//

695

              plr->SetLinkData (addrLocal);

696

              plr->SetMetric (metricLocal);

697

              pLSA->AddLinkRecord (plr);

698

              plr = 0;

699

              continue;

700

701

581

702

      else if (ndLocal->IsPointToPoint () )

582

      else if (ndLocal->IsPointToPoint () )

703

583

704

          NS_LOG_LOGIC ("**** Router-LSA Point-to-point device");

584

          NS_LOG_LOGIC ("**** Point=to-point link");

705

//

585

          ProcessPointToPointLink (ndLocal, pLSA);

706

// Now, we have to find the Ipv4 interface whose netdevice is the one we

707

// just found.  This is still the IP on the local side of the channel.  There

708

// is a function to do this used down in the guts of the stack, but it's not

709

// exported so we had to whip up an equivalent.

710

//

711

          uint32_t ifIndexLocal;

712

          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);

713

          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

714

//

715

// Now that we have the Ipv4 interface index, we can get the address and mask

716

// we need.

717

//

718

          Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

719

          Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

720

          NS_LOG_LOGIC ("Working with local address " << addrLocal);

721

          uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);

722

//

723

// Now, we're going to walk over to the remote net device on the other end of

724

// the point-to-point channel we now know we have.  This is where our adjacent

725

// router (to use OSPF lingo) is running.

726

//

727

          Ptr<Channel> ch = ndLocal->GetChannel();

728

          if (ch == NULL)

729

730

              continue;

731

732

//

733

// Get the net device on the other side of the point-to-point channel.

734

//

735

          Ptr<NetDevice> ndRemote = GetAdjacent(ndLocal, ch);

736

//

737

// The adjacent net device is aggregated to a node.  We need to ask that net

738

// device for its node, then ask that node for its Ipv4 interface.  Note a

739

// requirement that nodes on either side of a point-to-point link must have

740

// internet stacks.

741

//

742

          Ptr<Node> nodeRemote = ndRemote->GetNode();

743

          Ptr<Ipv4> ipv4Remote = nodeRemote->GetObject<Ipv4> ();

744

          NS_ABORT_MSG_UNLESS (ipv4Remote,

745

            "GlobalRouter::DiscoverLSAs (): GetObject for remote <Ipv4> failed");

746

//

747

// Per the OSPF spec, we're going to need the remote router ID, so we might as

748

// well get it now.

749

//

750

// While we're at it, further note the requirement that nodes on either side of

751

// a point-to-point link must participateg in global routing and therefore have

752

// a GlobalRouter interface aggregated.

753

//

754

          Ptr<GlobalRouter> srRemote = nodeRemote->GetObject<GlobalRouter> ();

755

          NS_ABORT_MSG_UNLESS(srRemote,

756

            "GlobalRouter::DiscoverLSAs(): GetObject for remote <GlobalRouter> failed");

757

758

          Ipv4Address rtrIdRemote = srRemote->GetRouterId();

759

          NS_LOG_LOGIC ("Working with remote router " << rtrIdRemote);

760

//

761

// Now, just like we did above, we need to get the IP interface index for the

762

// net device on the other end of the point-to-point channel.  We have yet another

763

// assumption that point to point devices are incompatible with bridges and that

764

// the remote device must have an associated ip interface.

765

//

766

          uint32_t ifIndexRemote;

767

          rc = FindIfIndexForDevice(nodeRemote, ndRemote, ifIndexRemote);

768

          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with remote device");

769

//

770

// Now that we have the Ipv4 interface, we can get the (remote) address and

771

// mask we need.

772

//

773

          Ipv4Address addrRemote = ipv4Remote->GetAddress(ifIndexRemote);

774

          Ipv4Mask maskRemote = ipv4Remote->GetNetworkMask(ifIndexRemote);

775

          NS_LOG_LOGIC ("Working with remote address " << addrRemote);

776

//

777

// Now we can fill out the link records for this link.  There are always two

778

// link records; the first is a point-to-point record describing the link and

779

// the second is a stub network record with the network number.

780

//

781

          GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;

782

          plr->SetLinkType (GlobalRoutingLinkRecord::PointToPoint);

783

          plr->SetLinkId (rtrIdRemote);

784

          plr->SetLinkData (addrLocal);

785

          plr->SetMetric (metricLocal);

786

          pLSA->AddLinkRecord (plr);

787

          plr = 0;

788

789

          plr = new GlobalRoutingLinkRecord;

790

          plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

791

          plr->SetLinkId (addrRemote);

792

          plr->SetLinkData (Ipv4Address(maskRemote.Get()));  // Frown

793

          plr->SetMetric (metricLocal);

794

          pLSA->AddLinkRecord (plr);

795

          plr = 0;

796

586

797

      else

587

      else

798

588

799

          NS_ASSERT_MSG(0, "GlobalRouter::DiscoverLSAs (): unknown link type");

589

          NS_ASSERT_MSG(0, "GlobalRouter::DiscoverLSAs (): unknown link type");

800

590

801

591

802

//

592

803

// The LSA goes on a list of LSAs in case we want to begin exporting other

593

  NS_LOG_LOGIC ("========== LSA for node " << node->GetId () << " ==========");

804

// kinds of advertisements (than Router LSAs).

594

  NS_LOG_LOGIC (*pLSA);

805

//

806

  m_LSAs.push_back (pLSA);

595

  m_LSAs.push_back (pLSA);

807

  NS_LOG_LOGIC ("========== Link State Advertisement for node " << node->GetId () << " ==========");

596

  pLSA = 0;

808

  NS_LOG_LOGIC (*pLSA);

809

597

810

//

598

//

811

// Now, determine whether we need to build a NetworkLSA.  This is the case if

599

  // Now, determine whether we need to build a NetworkLSA.  This is the case if

812

// we found at least one designated router.

600

  // we found at least one designated router.

813

//

601

//

814

  if (listOfDRInterfaces.size () > 0)

602

  uint32_t nDesignatedRouters = c.GetN ();

603

  if (nDesignatedRouters > 0)

815

604

816

      NS_LOG_LOGIC ("Build Network LSA");

605

      NS_LOG_LOGIC ("Build Network LSAs");

817

      for (std::list<Ptr<NetDevice> >::iterator i = listOfDRInterfaces.begin ();

606

      BuildNetworkLSAs (c);

818

        i != listOfDRInterfaces.end (); i++)

819

820

//

821

// Build one NetworkLSA for each net device talking to a netwok that we are the

822

// designated router for.

823

//

824

          Ptr<NetDevice> ndLocal = *i;

825

826

          uint32_t ifIndexLocal;

827

          bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);

828

          NS_ABORT_MSG_IF (rc == false, "GlobalRouter::DiscoverLSAs (): No interface index associated with device");

829

830

          Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

831

          Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

832

833

          GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;

834

          pLSA->SetLSType (GlobalRoutingLSA::NetworkLSA);

835

          pLSA->SetLinkStateId (addrLocal);

836

          pLSA->SetAdvertisingRouter (m_routerId);

837

          pLSA->SetNetworkLSANetworkMask (maskLocal);

838

          pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

839

//

840

// Build a list of AttachedRouters by walking the devices in the channel

841

// and, if we find a node with a GlobalRouter interface and an IPv4

842

// interface associated with that device, we call it an attached router.

843

//

844

          Ptr<Channel> ch = ndLocal->GetChannel();

845

          uint32_t nDevices = ch->GetNDevices();

846

          NS_ASSERT (nDevices);

847

          for (uint32_t i = 0; i < nDevices; i++)

848

849

              Ptr<NetDevice> tempNd = ch->GetDevice (i);

850

              NS_ASSERT (tempNd);

851

              Ptr<Node> tempNode = tempNd->GetNode ();

852

//

853

// Does the node in question have a GlobalRouter interface?  If not it can

854

// hardly be considered an attached router.

855

//

856

              Ptr<GlobalRouter> rtr = tempNode->GetObject<GlobalRouter> ();

857

              if (rtr == 0)

858

859

                  continue;

860

861

862

//

863

// Does the attached node have an ipv4 interface for the device we're probing?

864

// If not, it can't play router.

865

//

866

              uint32_t tempIfIndex;

867

              if (FindIfIndexForDevice (tempNode, tempNd, tempIfIndex))

868

869

                  Ptr<Ipv4> tempIpv4 = tempNode->GetObject<Ipv4> ();

870

                  NS_ASSERT (tempIpv4);

871

                  Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);

872

                  pLSA->AddAttachedRouter (tempAddr);

873

874

875

          m_LSAs.push_back (pLSA);

876

          NS_LOG_LOGIC (*pLSA);

877

878

607

879

608

880

  return m_LSAs.size ();

609

  return m_LSAs.size ();

610

611

612

  void

613

GlobalRouter::ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c)

614

615

  NS_LOG_FUNCTION (nd << pLSA << &c);

616

617

  GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;

618

  NS_ABORT_MSG_IF (plr == 0, "GlobalRouter::ProcessBroadcastLink(): Can't alloc link record");

619

620

//

621

  // We have some preliminaries to do to get enough information to proceed.

622

  // This information we need comes from the internet stack, so notice that

623

  // there is an implied assumption that global routing is only going to

624

  // work with devices attached to the internet stack (have an ipv4 interface

625

  // associated to them.

626

//

627

  Ptr<Node> node = nd->GetNode ();

628

629

  uint32_t ifIndexLocal;

630

  bool rc = FindIfIndexForDevice(node, nd, ifIndexLocal);

631

  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::ProcessBroadcastLink(): No interface index associated with device");

632

633

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

634

  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::ProcessBroadcastLink (): GetObject for <Ipv4> interface failed");

635

636

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

637

  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

638

  NS_LOG_LOGIC ("Working with local address " << addrLocal);

639

  uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);

640

641

//

642

  // Check to see if the net device is connected to a channel/network that has

643

  // another router on it.  If there is no other router on the link (but us) then

644

  // this is a stub network.  If we find another router, then what we have here

645

  // is a transit network.

646

//

647

  if (AnotherRouterOnLink (nd) == false)

648

649

//

650

      // This is a net device connected to a stub network

651

//

652

      NS_LOG_LOGIC("**** Router-LSA Stub Network");

653

      plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

654

655

//

656

      // According to OSPF, the Link ID is the IP network number of

657

      // the attached network.

658

//

659

      plr->SetLinkId (addrLocal.CombineMask(maskLocal));

660

661

//

662

      // and the Link Data is the network mask; converted to Ipv4Address

663

//

664

      Ipv4Address maskLocalAddr;

665

      maskLocalAddr.Set(maskLocal.Get ());

666

      plr->SetLinkData (maskLocalAddr);

667

      plr->SetMetric (metricLocal);

668

      pLSA->AddLinkRecord(plr);

669

      plr = 0;

670

671

  else

672

673

//

674

      // We have multiple routers on a broadcast interface, so this is

675

      // a transit network.

676

//

677

      NS_LOG_LOGIC ("**** Router-LSA Transit Network");

678

      plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

679

680

//

681

      // By definition, the router with the lowest IP address is the

682

      // designated router for the network.  OSPF says that the Link ID

683

      // gets the IP interface address of the designated router in this

684

      // case.

685

//

686

      Ipv4Address desigRtr = FindDesignatedRouterForLink (nd);

687

      if (desigRtr == addrLocal)

688

689

          c.Add (nd);

690

          NS_LOG_LOGIC ("Node " << node->GetId () << " elected a designated router");

691

692

      plr->SetLinkId (desigRtr);

693

694

//

695

      // OSPF says that the Link Data is this router's own IP address.

696

//

697

      plr->SetLinkData (addrLocal);

698

      plr->SetMetric (metricLocal);

699

      pLSA->AddLinkRecord (plr);

700

      plr = 0;

701

702

703

704

  void

705

GlobalRouter::ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA)

706

707

  NS_LOG_FUNCTION (ndLocal << pLSA);

708

709

//

710

  // We have some preliminaries to do to get enough information to proceed.

711

  // This information we need comes from the internet stack, so notice that

712

  // there is an implied assumption that global routing is only going to

713

  // work with devices attached to the internet stack (have an ipv4 interface

714

  // associated to them.

715

//

716

  Ptr<Node> nodeLocal = ndLocal->GetNode ();

717

718

  uint32_t ifIndexLocal;

719

  bool rc = FindIfIndexForDevice(nodeLocal, ndLocal, ifIndexLocal);

720

  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::ProcessPointToPointLink (): No interface index associated with device");

721

722

  Ptr<Ipv4> ipv4Local = nodeLocal->GetObject<Ipv4> ();

723

  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::ProcessPointToPointLink (): GetObject for <Ipv4> interface failed");

724

725

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

726

  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

727

  NS_LOG_LOGIC ("Working with local address " << addrLocal);

728

  uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);

729

730

//

731

  // Now, we're going to walk over to the remote net device on the other end of

732

  // the point-to-point channel we know we have.  This is where our adjacent

733

  // router (to use OSPF lingo) is running.

734

//

735

  Ptr<Channel> ch = ndLocal->GetChannel();

736

737

//

738

  // Get the net device on the other side of the point-to-point channel.

739

//

740

  Ptr<NetDevice> ndRemote = GetAdjacent(ndLocal, ch);

741

742

//

743

  // The adjacent net device is aggregated to a node.  We need to ask that net

744

  // device for its node, then ask that node for its Ipv4 interface.  Note a

745

  // requirement that nodes on either side of a point-to-point link must have

746

  // internet stacks; and an assumption that point-to-point links are incompatible

747

  // with bridging.

748

//

749

  Ptr<Node> nodeRemote = ndRemote->GetNode();

750

  Ptr<Ipv4> ipv4Remote = nodeRemote->GetObject<Ipv4> ();

751

  NS_ABORT_MSG_UNLESS (ipv4Remote,

752

                       "GlobalRouter::ProcessPointToPointLink(): GetObject for remote <Ipv4> failed");

753

754

//

755

  // Further note the requirement that nodes on either side of a point-to-point

756

  // link must participate in global routing and therefore have a GlobalRouter

757

  // interface aggregated.

758

//

759

  Ptr<GlobalRouter> rtrRemote = nodeRemote->GetObject<GlobalRouter> ();

760

  NS_ABORT_MSG_UNLESS(rtrRemote,

761

                      "GlobalRouter::ProcessPointToPointLinks(): GetObject for remote <GlobalRouter> failed");

762

763

//

764

  // We're going to need the remote router ID, so we might as well get it now.

765

//

766

  Ipv4Address rtrIdRemote = rtrRemote->GetRouterId();

767

  NS_LOG_LOGIC ("Working with remote router " << rtrIdRemote);

768

769

//

770

  // Now, just like we did above, we need to get the IP interface index for the

771

  // net device on the other end of the point-to-point channel.

772

//

773

  uint32_t ifIndexRemote;

774

  rc = FindIfIndexForDevice(nodeRemote, ndRemote, ifIndexRemote);

775

  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::ProcessPointToPointLinks(): No interface index associated with remote device");

776

777

//

778

  // Now that we have the Ipv4 interface, we can get the (remote) address and

779

  // mask we need.

780

//

781

  Ipv4Address addrRemote = ipv4Remote->GetAddress(ifIndexRemote);

782

  Ipv4Mask maskRemote = ipv4Remote->GetNetworkMask(ifIndexRemote);

783

  NS_LOG_LOGIC ("Working with remote address " << addrRemote);

784

785

//

786

  // Now we can fill out the link records for this link.  There are always two

787

  // link records; the first is a point-to-point record describing the link and

788

  // the second is a stub network record with the network number.

789

//

790

  GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;

791

  NS_ABORT_MSG_IF (plr == 0, "GlobalRouter::ProcessPointToPointLink(): Can't alloc link record");

792

  plr->SetLinkType (GlobalRoutingLinkRecord::PointToPoint);

793

  plr->SetLinkId (rtrIdRemote);

794

  plr->SetLinkData (addrLocal);

795

  plr->SetMetric (metricLocal);

796

  pLSA->AddLinkRecord (plr);

797

  plr = 0;

798

799

  plr = new GlobalRoutingLinkRecord;

800

  NS_ABORT_MSG_IF (plr == 0, "GlobalRouter::ProcessPointToPointLink(): Can't alloc link record");

801

  plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

802

  plr->SetLinkId (addrRemote);

803

  plr->SetLinkData (Ipv4Address(maskRemote.Get()));  // Frown

804

  plr->SetMetric (metricLocal);

805

  pLSA->AddLinkRecord (plr);

806

  plr = 0;

807

808

809

  void

810

GlobalRouter::BuildNetworkLSAs (NetDeviceContainer c)

811

812

  NS_LOG_FUNCTION (&c);

813

814

  uint32_t nDesignatedRouters = c.GetN ();

815

816

  for (uint32_t i = 0; i < nDesignatedRouters; ++i)

817

818

//

819

      // Build one NetworkLSA for each net device talking to a network that we are the

820

      // designated router for.  These devices are in the provided container.

821

//

822

      Ptr<NetDevice> ndLocal = c.Get (i);

823

      Ptr<Node> node = ndLocal->GetNode ();

824

825

      uint32_t ifIndexLocal;

826

      bool rc = FindIfIndexForDevice(node, ndLocal, ifIndexLocal);

827

      NS_ABORT_MSG_IF (rc == false, "GlobalRouter::BuildNetworkLSAs (): No interface index associated with device");

828

829

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

830

      NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::ProcessPointToPointLink (): GetObject for <Ipv4> interface failed");

831

832

      Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);

833

      Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

834

835

      GlobalRoutingLSA *pLSA = new GlobalRoutingLSA;

836

      NS_ABORT_MSG_IF (pLSA == 0, "GlobalRouter::BuildNetworkLSAs(): Can't alloc link record");

837

838

      pLSA->SetLSType (GlobalRoutingLSA::NetworkLSA);

839

      pLSA->SetLinkStateId (addrLocal);

840

      pLSA->SetAdvertisingRouter (m_routerId);

841

      pLSA->SetNetworkLSANetworkMask (maskLocal);

842

      pLSA->SetStatus (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED);

843

844

//

845

      // Build a list of AttachedRouters by walking the devices in the channel

846

      // and, if we find a node with a GlobalRouter interface and an IPv4

847

      // interface associated with that device, we call it an attached router.

848

//

849

      Ptr<Channel> ch = ndLocal->GetChannel();

850

      uint32_t nDevices = ch->GetNDevices();

851

      NS_ASSERT (nDevices);

852

853

      for (uint32_t i = 0; i < nDevices; i++)

854

855

          Ptr<NetDevice> tempNd = ch->GetDevice (i);

856

          NS_ASSERT (tempNd);

857

          Ptr<Node> tempNode = tempNd->GetNode ();

858

859

//

860

          // Does the node in question have a GlobalRouter interface?  If not it can

861

          // hardly be considered an attached router.

862

//

863

          Ptr<GlobalRouter> rtr = tempNode->GetObject<GlobalRouter> ();

864

          if (rtr == 0)

865

866

              continue;

867

868

869

//

870

          // Does the attached node have an ipv4 interface for the device we're probing?

871

          // If not, it can't play router.

872

//

873

          uint32_t tempIfIndex;

874

          if (FindIfIndexForDevice (tempNode, tempNd, tempIfIndex))

875

876

              Ptr<Ipv4> tempIpv4 = tempNode->GetObject<Ipv4> ();

877

              NS_ASSERT (tempIpv4);

878

              Ipv4Address tempAddr = tempIpv4->GetAddress(tempIfIndex);

879

              pLSA->AddAttachedRouter (tempAddr);

880

881

882

      m_LSAs.push_back (pLSA);

883

      pLSA = 0;

884

881

885

882

886

883

//

887

//

Lines 1026-1036 GlobalRouter::GetLSA (uint32_t n, Global	Link Here

1026

// other end.  This only makes sense with a point-to-point channel.

1030

// other end.  This only makes sense with a point-to-point channel.

1027

//

1031

//

1028

  Ptr<NetDevice>

1032

  Ptr<NetDevice>

1029

GlobalRouter::GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const

1033

GlobalRouter::GetAdjacent (Ptr<NetDevice> nd, Ptr<Channel> ch) const

1030

1034

1031

  NS_LOG_FUNCTION_NOARGS ();

1035

  NS_LOG_FUNCTION_NOARGS ();

1032

  NS_ASSERT_MSG(ch->GetNDevices() == 2,

1036

  NS_ASSERT_MSG(ch->GetNDevices() == 2, "GlobalRouter::GetAdjacent (): Channel with other than two devices");

1033

    "GlobalRouter::GetAdjacent (): Channel with other than two devices");

1034

//

1037

//

1035

// This is a point to point channel with two endpoints.  Get both of them.

1038

// This is a point to point channel with two endpoints.  Get both of them.

1036

//

1039

//

Lines 1065-1071 GlobalRouter::GetAdjacent(Ptr<NetDevice>	Link Here

1065

// is bridged, there will not be an interface associated directly with the device.

1068

// is bridged, there will not be an interface associated directly with the device.

1066

//

1069

//

1067

  bool

1070

  bool

1068

GlobalRouter::FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const

1071

GlobalRouter::FindIfIndexForDevice (Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const

1069

1072

1070

  NS_LOG_FUNCTION_NOARGS ();

1073

  NS_LOG_FUNCTION_NOARGS ();

1071

  NS_LOG_LOGIC("For node " << node->GetId () << " for net device " << nd );

1074

  NS_LOG_LOGIC("For node " << node->GetId () << " for net device " << nd );

Lines 1087-1093 GlobalRouter::FindIfIndexForDevice(Ptr<N	Link Here

1087

1090

1088

1091

1089

1092

1090

          NS_LOG_LOGIC ("**** Device " << nd << " has no associated ipv4 index");

1093

  NS_LOG_LOGIC ("**** Device " << nd << " has no associated ipv4 index");

1094

  return false;

1095

1096

1097

//

1098

// Decide whether or not a given net device is being bridged by a BridgeNetDevice.

1099

//

1100

  bool

1101

GlobalRouter::IsNetDeviceBridged (Ptr<NetDevice> nd) const

1102

1103

  Ptr<Node> node = nd->GetNode ();

1104

  uint32_t nDevices = node->GetNDevices();

1105

1106

//

1107

  // There is no bit on a net device that says it is being bridged, so we have

1108

  // to look for bridges on the node to which the device is attached.  If we

1109

  // find a bridge, we need to look through its bridge ports (the devices it

1110

  // bridges) to see if we find the device in question.

1111

//

1112

  for (uint32_t i = 0; i < nDevices; ++i)

1113

1114

      Ptr<NetDevice> nd = node->GetDevice(i);

1115

1116

      if (nd->IsBridge ())

1117

1118

          Ptr<BridgeNetDevice> bnd = nd->GetObject<BridgeNetDevice> ();

1119

          NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

1120

1121

          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)

1122

1123

              if (bnd->GetBridgePort (j) == nd)

1124

1125

                  return true;

1126

1127

1128

1129

1091

  return false;

1130

  return false;

1092

1131

1093

1132

(-)a/src/routing/global-routing/global-router-interface.h (+6 lines)

Lines 29-34	Link Here

#include "ns3/node.h"

#include "ns3/node.h"

#include "ns3/channel.h"

#include "ns3/channel.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-address.h"

#include "ns3/net-device-container.h"

#include "ns3/global-route-manager.h"

#include "ns3/global-route-manager.h"

namespace ns3 {

namespace ns3 {

Lines 642-647 private:	Link Here

642

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

643

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

643

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

644

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

644

  bool AnotherRouterOnLink (Ptr<NetDevice> nd) const;

645

  bool AnotherRouterOnLink (Ptr<NetDevice> nd) const;

646

  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

647

  void ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA);

648

  void BuildNetworkLSAs (NetDeviceContainer c);

649

  bool IsNetDeviceBridged (Ptr<NetDevice> nd) const;

650

645

651

646

  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t;

652

  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t;

647

  ListOfLSAs_t m_LSAs;

653

  ListOfLSAs_t m_LSAs;




{
  NS_LOG_FUNCTION (nd << pLSA << &c);

  if (nd->IsBridge ())
    {
      ProcessBridgedBroadcastLink (nd, pLSA, c);
    }
  else
    {
      ProcessSingleBroadcastLink (nd, pLSA, c);
    }
}

  void
GlobalRouter::ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c)
{
  NS_LOG_FUNCTION (nd << pLSA << &c);

  GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;
  NS_ABORT_MSG_IF (plr == 0, "GlobalRouter::ProcessSingleBroadcastLink(): Can't alloc link record");

  //
  // We have some preliminaries to do to get enough information to proceed.


  uint32_t ifIndexLocal;
  bool rc = FindIfIndexForDevice(node, nd, ifIndexLocal);
  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::ProcessSingleBroadcastLink(): No interface index associated with device");

  Ptr<Ipv4> ipv4Local = node->GetObject<Ipv4> ();
  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::ProcessSingleBroadcastLink (): GetObject for <Ipv4> interface failed");

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);

      // case.
      //
      Ipv4Address desigRtr = FindDesignatedRouterForLink (nd);
      if (desigRtr == addrLocal) 
        {
          c.Add (nd);
          NS_LOG_LOGIC ("Node " << node->GetId () << " elected a designated router");
        }
      plr->SetLinkId (desigRtr);
      
      //
      // OSPF says that the Link Data is this router's own IP address.
      //
      plr->SetLinkData (addrLocal);
      plr->SetMetric (metricLocal);
      pLSA->AddLinkRecord (plr);
      plr = 0;
    }
}

  void
GlobalRouter::ProcessBridgedBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c)
{
  NS_LOG_FUNCTION (nd << pLSA << &c);

  NS_ASSERT_MSG (nd->IsBridge (), "GlobalRouter::ProcessBridgedBroadcastLink(): Called with non-bridge net device");

  Ptr<BridgeNetDevice> bnd = nd->GetObject<BridgeNetDevice> ();
  NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

  //
  // We need to handle a bridge on the router.  This means that we have been 
  // given a net device that is a BridgeNetDevice.  It has an associated Ipv4
  // interface index and address.  Some number of other net devices live "under"
  // the bridge device as so-called bridge ports.  In a nutshell, what we have
  // to do is to repeat what is done for a single broadcast link on all of 
  // those net devices living under the bridge (trolls?)
  //
  bool areTransitNetwork = false;
  Ipv4Address desigRtr ("255.255.255.255");

  for (uint32_t i = 0; i < bnd->GetNBridgePorts (); ++i)
    {
      Ptr<NetDevice> ndTemp = bnd->GetBridgePort (i);
      GlobalRoutingLSA *pLsaTest = new GlobalRoutingLSA;
      NetDeviceContainer cTest;
      ProcessSingleBroadcastLink (ndTemp, pLsaTest, cTest);

      //
      // The GlobalRoutingLSA pLsaTest will now have a link record attached to
      // it indicating what was found.  If another router is found on any one
      // of the bridged networks, we need to treat the whole bridge as a transit 
      // network.
      //
      // If the link type is a transit network, then we have got to do some work
      // to figure out what to do about the other routers on the bridge.
      //
      if (pLsaTest->GetLinkRecord (0)->GetLinkType () == GlobalRoutingLinkRecord::TransitNetwork)
        {
          areTransitNetwork = true;

          //
          // If we're going to be a transit network, then we have got to elect
          // a designated router for the whole bridge.  This means finding the
          // router with the lowest IP address on the whole bridge.  We ask 
          // for the lowest address on each segment and pick the lowest of them
          // all.
          //
          Ipv4Address desigRtrTemp = FindDesignatedRouterForLink (ndTemp);
          if (desigRtrTemp < desigRtr)
            {
              desigRtr = desigRtrTemp;
            }
        }
    }

  //
  // That's all the information we need to put it all together, just like we did
  // in the case of a single broadcast link.
  //

  GlobalRoutingLinkRecord *plr = new GlobalRoutingLinkRecord;
  NS_ABORT_MSG_IF (plr == 0, "GlobalRouter::ProcessBridgedBroadcastLink(): Can't alloc link record");

  //
  // We have some preliminaries to do to get enough information to proceed.
  // This information we need comes from the internet stack, so notice that
  // there is an implied assumption that global routing is only going to 
  // work with devices attached to the internet stack (have an ipv4 interface
  // associated to them.
  //
  Ptr<Node> node = nd->GetNode ();

  uint32_t ifIndexLocal;
  bool rc = FindIfIndexForDevice(node, nd, ifIndexLocal);
  NS_ABORT_MSG_IF (rc == false, "GlobalRouter::ProcessBridgedBroadcastLink(): No interface index associated with device");

  Ptr<Ipv4> ipv4Local = node->GetObject<Ipv4> ();
  NS_ABORT_MSG_UNLESS (ipv4Local, "GlobalRouter::ProcessBridgedBroadcastLink (): GetObject for <Ipv4> interface failed");

  Ipv4Address addrLocal = ipv4Local->GetAddress(ifIndexLocal);
  Ipv4Mask maskLocal = ipv4Local->GetNetworkMask(ifIndexLocal);
  NS_LOG_LOGIC ("Working with local address " << addrLocal);
  uint16_t metricLocal = ipv4Local->GetMetric (ifIndexLocal);

  if (areTransitNetwork == false)
    {
      //
      // This is a net device connected to a bridge of stub networks
      //
      NS_LOG_LOGIC("**** Router-LSA Stub Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

      // 
      // According to OSPF, the Link ID is the IP network number of 
      // the attached network.
      //
      plr->SetLinkId (addrLocal.CombineMask(maskLocal));

      //
      // and the Link Data is the network mask; converted to Ipv4Address
      //
      Ipv4Address maskLocalAddr;
      maskLocalAddr.Set(maskLocal.Get ());
      plr->SetLinkData (maskLocalAddr);
      plr->SetMetric (metricLocal);
      pLSA->AddLinkRecord(plr);
      plr = 0;
    }
  else
    {
      //
      // We have multiple routers on a bridged broadcast interface, so this is
      // a transit network.
      //
      NS_LOG_LOGIC ("**** Router-LSA Transit Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

      // 
      // By definition, the router with the lowest IP address is the
      // designated router for the network.  OSPF says that the Link ID
      // gets the IP interface address of the designated router in this 
      // case.
      //
      if (desigRtr == addrLocal) 
        {
          c.Add (nd);

(-)a/src/routing/global-routing/global-router-interface.h (+3 lines)

Lines 644-649 private:	Link Here

644

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

644

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

645

  bool AnotherRouterOnLink (Ptr<NetDevice> nd) const;

645

  bool AnotherRouterOnLink (Ptr<NetDevice> nd) const;

646

  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

646

  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

647

  void ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

648

  void ProcessBridgedBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

649

647

  void ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA);

650

  void ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA);

648

  void BuildNetworkLSAs (NetDeviceContainer c);

651

  void BuildNetworkLSAs (NetDeviceContainer c);

649

  bool IsNetDeviceBridged (Ptr<NetDevice> nd) const;

652

  bool IsNetDeviceBridged (Ptr<NetDevice> nd) const;





      //
      // Check to see if the net device we just got has a corresponding IP 
      // interface (could be a pure L2 NetDevice) -- for example a net device
      // associated with a bridge.
      //
      bool isIp = false;
      for (uint32_t i = 0; i < ipv4Local->GetNInterfaces (); ++i )

  // this is a stub network.  If we find another router, then what we have here
  // is a transit network.
  //
  if (AnotherRouterOnLink (nd, true) == false)
    {
      //
      // This is a net device connected to a stub network

  for (uint32_t i = 0; i < bnd->GetNBridgePorts (); ++i)
    {
      Ptr<NetDevice> ndTemp = bnd->GetBridgePort (i);
      GlobalRoutingLSA *pLsaTest = new GlobalRoutingLSA;
      NetDeviceContainer cTest;
      ProcessSingleBroadcastLink (ndTemp, pLsaTest, cTest);

      //
      // We have to decide if we are a transit network.  This is characterized
      // by the presence of another router on the network segment.  If we find
      // another router on any of our bridged links, we are a transit network.
      // network.
      //
      if (AnotherRouterOnLink (ndTemp, true))
      // to figure out what to do about the other routers on the bridge.
      //
      if (pLsaTest->GetLinkRecord (0)->GetLinkType () == GlobalRoutingLinkRecord::TransitNetwork)
        {
          areTransitNetwork = true;


//
// Given a node and an attached net device, take a look off in the channel to 
// which the net device is attached and look for a node on the other side
// that has a GlobalRouter interface aggregated.  Life gets more complicated
// when there is a bridged net device on the other side.
//
  bool
GlobalRouter::AnotherRouterOnLink (Ptr<NetDevice> nd, bool allowRecursion) const
{
  NS_LOG_FUNCTION (nd << allowRecursion);

  Ptr<Channel> ch = nd->GetChannel();
  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  //
  // Look through all of the devices on the channel to which the net device
  // in questin is attached.
  //
  for (uint32_t i = 0; i < nDevices; i++)
    {
      NS_LOG_LOGIC ("**** Examine device " << i << "on node " << nd->GetNode ()->GetId ());
      NS_ASSERT (ndTemp);

      Ptr<NetDevice> ndOther = ch->GetDevice (i);
      NS_ASSERT (ndOther);

      // 
      // Ignore the net device itself.
      //
      if (ndOther == nd)
        {
          NS_LOG_LOGIC ("**** Self");
          continue;
        }

      //
      // For all other net devices, we need to check and see if a router
      // is present.  If the net device on the other side is a bridged
      // device, we need to consider all of the other devices on the 
      // bridge.
      //
      Ptr<BridgeNetDevice> bnd = NetDeviceIsBridged (ndOther);
      if (bnd)
        {
          NS_LOG_LOGIC ("**** Device is bridged");
          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              NS_LOG_LOGIC ("**** Examining bridge port " << j);
              Ptr<NetDevice> ndBridged = bnd->GetBridgePort (j);
              if (ndBridged == ndOther)
                {
                  NS_LOG_LOGIC ("**** Self");
                  continue;
                }
              if (allowRecursion)
                {
                  NS_LOG_LOGIC ("**** Recursing");
                  if (AnotherRouterOnLink (ndBridged, false))
                    {
                      NS_LOG_LOGIC ("**** Return true");
                      return true;
                    }
                }
            }
          NS_LOG_LOGIC ("**** Return false");
          return false;
        }

      NS_LOG_LOGIC ("**** Device is not bridged");
      Ptr<Node> nodeTemp = ndOther->GetNode ();
      NS_ASSERT (nodeTemp);

      Ptr<GlobalRouter> rtr = nodeTemp->GetObject<GlobalRouter> ();
      if (rtr)
        {
          NS_LOG_LOGIC ("**** Return true");
          return true;
        }
    }
  NS_LOG_LOGIC ("**** Return false");
  return false;
}


//
// Decide whether or not a given net device is being bridged by a BridgeNetDevice.
//
  Ptr<BridgeNetDevice>
GlobalRouter::NetDeviceIsBridged (Ptr<NetDevice> nd) const
{
  NS_LOG_FUNCTION (nd);

  Ptr<Node> node = nd->GetNode ();
  uint32_t nDevices = node->GetNDevices();


  //
  for (uint32_t i = 0; i < nDevices; ++i)
    {
      Ptr<NetDevice> ndTest = node->GetDevice(i);
      NS_LOG_LOGIC ("**** Examine device " << i << " " << ndTest);

      if (ndTest->IsBridge ())
        {
          NS_LOG_LOGIC ("**** device " << i << " is a bridge net device");
          Ptr<BridgeNetDevice> bnd = ndTest->GetObject<BridgeNetDevice> ();
          NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              NS_LOG_LOGIC ("**** Examine bridge port " << j << " " << bnd->GetBridgePort (j));
              if (bnd->GetBridgePort (j) == nd)
                {
                  NS_LOG_LOGIC ("**** Net device " << nd << " is bridged by " << bnd);
                  return bnd;
                }
            }
        }
    }
  NS_LOG_LOGIC ("**** Net device " << nd << " is not bridged");
  return 0;
}

} // namespace ns3




#include "ns3/channel.h"
#include "ns3/ipv4-address.h"
#include "ns3/net-device-container.h"
#include "ns3/bridge-net-device.h"
#include "ns3/global-route-manager.h"

namespace ns3 {

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;
  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;
  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;
  bool AnotherRouterOnLink (Ptr<NetDevice> nd, bool allowRecursion) const;
  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);
  void ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);
  void ProcessBridgedBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

  void ProcessPointToPointLink (Ptr<NetDevice> ndLocal, GlobalRoutingLSA *pLSA);
  void BuildNetworkLSAs (NetDeviceContainer c);
  Ptr<BridgeNetDevice> NetDeviceIsBridged (Ptr<NetDevice> nd) const;


  typedef std::list<GlobalRoutingLSA*> ListOfLSAs_t;




// Or, more abstractly, recognizing that bridge 1 and bridge 2 are nodes 
// with three net devices:
//
//        n0     n1                (n0 = 10.1.1.2)
//        |      |                 (n1 = 10.1.1.3)  Note odd addressing
//       -----------               (n2 = 10.1.1.1)
//       | bridge1 | <- n5  
//       -----------
//           |    
//         router    <- n2
//           |
//       -----------
//       | bridge2 | <- n6
//       -----------               (n2 = 10.1.2.1)
//        |      |                 (n3 = 10.1.2.2)
//        n3     n4                (n4 = 10.1.2.3)
//
// So, this example shows two broadcast domains, each interconnected by a bridge
// with a router node (n2) interconnecting the layer-2 broadcast domains

// It is meant to mirror somewhat the csma-bridge example but adds another
// bridged link separated by a router.
// 
// - CBR/UDP flows from n0 (10.1.1.2) to n1 (10.1.1.3) and from n3 (10.1.2.2) to n0 (10.1.1.3)
// - DropTail queues 
// - Global static routing
// - Tracing of queues and packet receptions to file "csma-bridge-one-hop.tr"

  // Create an optional packet sink to receive these packets
  PacketSinkHelper sink ("ns3::UdpSocketFactory",
                         Address (InetSocketAddress (Ipv4Address::GetAny (), port)));
  ApplicationContainer sink1 = sink.Install (n1);
  sink1.Start (Seconds (1.0));
  sink1.Stop (Seconds (10.0));

  // 
  // Create a similar flow from n3 to n0, starting at time 1.1 seconds

  onoff.SetAttribute ("Remote", 
                      AddressValue (InetSocketAddress (Ipv4Address ("10.1.1.2"), port)));
  ApplicationContainer app2 = onoff.Install (n3);

  sink.Install (n0);

  app2.Start (Seconds (1.1));
  app2.Stop (Seconds (10.0));

  ApplicationContainer sink2 = sink.Install (n0);
  sink2.Start (Seconds (1.1));
  sink2.Stop (Seconds (10.0));

  //
  // Configure tracing of all enqueue, dequeue, and NetDevice receive events.




  void 
GlobalRoutingLSA::Print (std::ostream &os) const
{
  os << std::endl;
  os << "========== Global Routing LSA ==========" << std::endl;
  os << "m_lsType = " << m_lsType;
  if (m_lsType == GlobalRoutingLSA::RouterLSA) 
    {
      os << " (GlobalRoutingLSA::RouterLSA)";
    }
  else if (m_lsType == GlobalRoutingLSA::NetworkLSA) 
    {
      os << " (GlobalRoutingLSA::NetworkLSA)";
    }
  else
    {
      os << "(Unknown LSType)";
    }
  os << std::endl;

  os << "m_linkStateId = " << m_linkStateId << " (Router ID)" << std::endl;
  os << "m_advertisingRtr = " << m_advertisingRtr << " (Router ID)" << std::endl;

  if (m_lsType == GlobalRoutingLSA::RouterLSA) 
    {

            i++)
        {
          GlobalRoutingLinkRecord *p = *i;

          os << "---------- RouterLSA Link Record ----------" << std::endl;
          os << "m_linkType = " << p->m_linkType;
          if (p->m_linkType == GlobalRoutingLinkRecord::TransitNetwork)
            {
              os << " (GlobalRoutingLinkRecord::TransitNetwork)" << std::endl;
              os << "m_linkId = " << p->m_linkId << " (Designated router for network)" << std::endl;
              os << "m_linkData = " << p->m_linkData << " (This router's IP address)" << std::endl;
              os << "m_metric = " << p->m_metric << std::endl;
            }
          else if (p->GetLinkType () == GlobalRoutingLinkRecord::StubNetwork)
            {
              os << "(GlobalRoutingLinkRecord::StubNetwork)" << std::endl;
              os << "m_linkId = " << p->m_linkId << " (Network number of attached network)" << std::endl;
              os << "m_linkData = " << p->m_linkData << " (Network mask of attached network)" << std::endl;
              os << "m_metric = " << p->m_metric << std::endl;
            }
          else
            {
              os << "(Unknown LinkType)" << std::endl;
              os << "m_linkId = " << p->m_linkId << std::endl;
              os << "m_linkData = " << p->m_linkData << std::endl;
              os << "m_metric = " << p->m_metric << std::endl;
            }
          os << "---------- End RouterLSA Link Record ----------" << std::endl;
        }
    }
  else if (m_lsType == GlobalRoutingLSA::NetworkLSA) 
    {
      os << "---------- NetworkLSA Link Record ----------" << std::endl;
      os << "m_networkLSANetworkMask = " << m_networkLSANetworkMask << std::endl;
      for ( ListOfAttachedRouters_t::const_iterator i = m_attachedRouters.begin (); i != m_attachedRouters.end (); i++)
      for ( ListOfAttachedRouters_t::const_iterator i = 
            m_attachedRouters.begin ();
            i != m_attachedRouters.end (); 
            i++)
        {
          Ipv4Address p = *i;
          os << "attachedRouter = " << p << std::endl;
        }
      os << "---------- End NetworkLSA Link Record ----------" << std::endl;
    }
  else 
    {
      NS_ASSERT_MSG(0, "Illegal LSA LSType: " << m_lsType);
    }
  os << "========== End Global Routing LSA ==========" << std::endl;
}

std::ostream& operator<< (std::ostream& os, GlobalRoutingLSA& lsa)

      // gets the IP interface address of the designated router in this 
      // case.
      //
      Ipv4Address desigRtr = FindDesignatedRouterForLink (nd, true);
      if (desigRtr == addrLocal) 
        {
          c.Add (nd);

          // for the lowest address on each segment and pick the lowest of them
          // all.
          //
          Ipv4Address desigRtrTemp = FindDesignatedRouterForLink (ndTemp, true);
          if (desigRtrTemp < desigRtr)
            {
              desigRtr = desigRtrTemp;

// connecting to the channel becomes the designated router for the link.
//
  Ipv4Address
GlobalRouter::FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal, bool allowRecursion) const
{
  NS_LOG_FUNCTION (ndLocal << allowRecursion);

  Ptr<Channel> ch = ndLocal->GetChannel();
  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  NS_LOG_LOGIC ("**** Looking for designated router off of net device " << ndLocal << " on node " << 
                ndLocal->GetNode ()->GetId ());

  Ipv4Address desigRtr ("255.255.255.255");

  //
  // Look through all of the devices on the channel to which the net device
  // in question is attached.
  //
  for (uint32_t i = 0; i < nDevices; i++)
    {
      Ptr<NetDevice> ndOther = ch->GetDevice (i);
      NS_ASSERT (ndOther);

      Ptr<Node> nodeOther = ndOther->GetNode ();

      NS_LOG_LOGIC ("**** Examine channel device " << i << " on node " << nodeOther->GetId ());
      // We require a designated router to have a GlobalRouter interface and
      // an internet stack that includes the Ipv4 interface.
      //
      Ptr<GlobalRouter> rtr = currentNode->GetObject<GlobalRouter> ();
      Ptr<Ipv4> ipv4 = currentNode->GetObject<Ipv4> ();
      if (rtr == 0 || ipv4 == 0 )
        {
          continue;
        }

      //
      // For all other net devices, we need to check and see if a router
      // is present.  If the net device on the other side is a bridged
      // device, we need to consider all of the other devices on the 
      // bridge as well (all of the bridge ports.
      // net device XXX which is not yet handled.
      //
      NS_LOG_LOGIC ("**** checking to see if the device is bridged");
      Ptr<BridgeNetDevice> bnd = NetDeviceIsBridged (ndOther);
      if (bnd)
        {
          NS_LOG_LOGIC ("**** Device is bridged by BridgeNetDevice " << bnd);

          //
          // It is possible that the bridge net device is sitting under a
          // router, so we have to check for the presence of that router
          // before we run off and follow all the links
          //
          // We require a designated router to have a GlobalRouter interface and
          // an internet stack that includes the Ipv4 interface.  If it doesn't
          // it can't play router.
          //
          NS_LOG_LOGIC ("**** Checking for router on bridge net device " << bnd);
          Ptr<GlobalRouter> rtr = nodeOther->GetObject<GlobalRouter> ();
          Ptr<Ipv4> ipv4 = nodeOther->GetObject<Ipv4> ();
          if (rtr && ipv4)
            {
              uint32_t ifIndexOther;
              if (FindIfIndexForDevice(nodeOther, bnd, ifIndexOther))
                {
                  NS_LOG_LOGIC ("**** Found router on bridge net device " << bnd);
                  Ipv4Address addrOther = ipv4->GetAddress (ifIndexOther);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("**** designated router now " << desigRtr);
                }
            }

          NS_LOG_LOGIC ("**** Looking through bridge ports of bridge net device " << bnd);
          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              Ptr<NetDevice> ndBridged = bnd->GetBridgePort (j);
              NS_LOG_LOGIC ("**** Examining bridge port " << j << " device " << ndBridged);
              if (ndBridged == ndOther)
                {
                  NS_LOG_LOGIC ("**** That bridge port is me, don't walk backward");
                  continue;
                }

              if (allowRecursion)
                {
                  NS_LOG_LOGIC ("**** Recursively looking for routers down bridge port " << ndBridged);
                  Ipv4Address addrOther = FindDesignatedRouterForLink (ndBridged, false);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("**** designated router now " << desigRtr);
                }
            }
        }
      else
        {
          NS_LOG_LOGIC ("**** This device is not bridged");
          Ptr<Node> nodeOther = ndOther->GetNode ();
          NS_ASSERT (nodeOther);

          //
          // We require a designated router to have a GlobalRouter interface and
          // an internet stack that includes the Ipv4 interface.  If it doesn't
          //
          Ptr<GlobalRouter> rtr = nodeOther->GetObject<GlobalRouter> ();
          Ptr<Ipv4> ipv4 = nodeOther->GetObject<Ipv4> ();
          if (rtr && ipv4)
            {
              uint32_t ifIndexOther;
              if (FindIfIndexForDevice(nodeOther, ndOther, ifIndexOther))
                {
                  NS_LOG_LOGIC ("**** Found router on net device " << ndOther);
                  Ipv4Address addrOther = ipv4->GetAddress (ifIndexOther);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("**** designated router now " << desigRtr);
                }
            }
        }
    }
  return desigRtr;
  //
  // Return the lowest IP address found, which will become the designated router
  // for the link.
  //
  NS_ASSERT_MSG (addr.IsBroadcast() == false, "GlobalRouter::FindDesignatedRouterForLink(): Bogus address");
  return addr;
}

//

  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  NS_LOG_LOGIC ("**** Looking for routers off of net device " << nd << " on node " << nd->GetNode ()->GetId ());

  //
  // Look through all of the devices on the channel to which the net device
  // in question is attached.
  //
  for (uint32_t i = 0; i < nDevices; i++)
    {
      NS_LOG_LOGIC ("**** Examine device " << i << "on node " << nd->GetNode ()->GetId ());

      Ptr<NetDevice> ndOther = ch->GetDevice (i);
      NS_ASSERT (ndOther);

      NS_LOG_LOGIC ("**** Examine channel device " << i << " on node " << ndOther->GetNode ()->GetId ());

      // 
      // Ignore the net device itself.
      //
      if (ndOther == nd)
        {
          NS_LOG_LOGIC ("**** Myself, skip");
          continue;
        }


      // device, we need to consider all of the other devices on the 
      // bridge.
      //
      NS_LOG_LOGIC ("**** checking to see if device is bridged");
      Ptr<BridgeNetDevice> bnd = NetDeviceIsBridged (ndOther);
      if (bnd)
        {
          NS_LOG_LOGIC ("**** Device is bridged by net device " << bnd);
          NS_LOG_LOGIC ("**** Looking through bridge ports of bridge net device " << bnd);
          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              NS_LOG_LOGIC ("**** Examining bridge port " << j);
              Ptr<NetDevice> ndBridged = bnd->GetBridgePort (j);
              NS_LOG_LOGIC ("**** Examining bridge port " << j << " device " << ndBridged);
              if (ndBridged == ndOther)
                {
                  NS_LOG_LOGIC ("**** That bridge port is me, skip");
                  continue;
                }

              if (allowRecursion)
                {
                  NS_LOG_LOGIC ("**** Recursively looking for routers on bridge port " << ndBridged);
                  if (AnotherRouterOnLink (ndBridged, false))
                    {
                      NS_LOG_LOGIC ("**** Found routers on bridge port, return true");
                      return true;
                    }
                }
            }
          NS_LOG_LOGIC ("**** No routers on bridged net device, return false");
          return false;
        }

      NS_LOG_LOGIC ("**** This device is not bridged");
      Ptr<Node> nodeTemp = ndOther->GetNode ();
      NS_ASSERT (nodeTemp);

      Ptr<GlobalRouter> rtr = nodeTemp->GetObject<GlobalRouter> ();
      if (rtr)
        {
          NS_LOG_LOGIC ("**** Found GlobalRouter interface, return true");
          return true;
        }
      else 
        {
          NS_LOG_LOGIC ("**** No GlobalRouter interface on device, continue search");
        }
    }
  NS_LOG_LOGIC ("**** No routers found, return false");
  return false;
}


(-)a/src/routing/global-routing/global-router-interface.h (-1 / +4 lines)

Lines 35-40	Link Here

namespace ns3 {

namespace ns3 {

class GlobalRouter;

/**

/**

 * @brief A single link record for a link state advertisement.

 * @brief A single link record for a link state advertisement.

Lines 45-50 class GlobalRoutingLinkRecord	Link Here

class GlobalRoutingLinkRecord

class GlobalRoutingLinkRecord

public:

public:

  friend class GlobalRoutingLSA;

/**

/**

 * @enum LinkType

 * @enum LinkType

 * @brief Enumeration of the possible types of Global Routing Link Records.

 * @brief Enumeration of the possible types of Global Routing Link Records.

Lines 642-648 private:	Link Here

642

645

643

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

646

  Ptr<NetDevice> GetAdjacent(Ptr<NetDevice> nd, Ptr<Channel> ch) const;

644

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

647

  bool FindIfIndexForDevice(Ptr<Node> node, Ptr<NetDevice> nd, uint32_t &index) const;

645

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal) const;

648

  Ipv4Address FindDesignatedRouterForLink (Ptr<NetDevice> ndLocal, bool allowRecursion) const;

646

  bool AnotherRouterOnLink (Ptr<NetDevice> nd, bool allowRecursion) const;

649

  bool AnotherRouterOnLink (Ptr<NetDevice> nd, bool allowRecursion) const;

647

  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

650

  void ProcessBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

648

  void ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);

651

  void ProcessSingleBroadcastLink (Ptr<NetDevice> nd, GlobalRoutingLSA *pLSA, NetDeviceContainer &c);




LOCAL_PYBINDGEN_PATH = os.path.join(os.getcwd(), "bindings", "python", "pybindgen")
#PYBINDGEN_BRANCH = 'lp:pybindgen'
PYBINDGEN_BRANCH = 'https://launchpad.net/pybindgen'
if os.environ.get('PYTHONPATH', ''):
    os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH + os.pathsep + os.environ.get('PYTHONPATH')
else:
    os.environ['PYTHONPATH'] = LOCAL_PYBINDGEN_PATH

## https://launchpad.net/pybindgen/
REQUIRED_PYBINDGEN_VERSION = (0, 9, 0, 605)
REQUIRED_PYGCCXML_VERSION = (0, 9, 5)


def add_to_python_path(path):
    if os.environ.get('PYTHONPATH', ''):
        os.environ['PYTHONPATH'] = path + os.pathsep + os.environ.get('PYTHONPATH')
    else:
        os.environ['PYTHONPATH'] = path

def set_pybindgen_pythonpath(env):
    if env['WITH_PYBINDGEN']:
        add_to_python_path(env['WITH_PYBINDGEN'])
    else:
        add_to_python_path(LOCAL_PYBINDGEN_PATH)


def set_options(opt):

                         "instead of using the system installed version."),
                   action="store_true", default=False,
                   dest='pybindgen_checkout')
    opt.add_option('--with-pybindgen',
                   help=('Path to an existing pybindgen source tree to use.'),
                   default=None,
                   dest='with_pybindgen', type="string")

def fetch_pybindgen(conf):
    """

        conf.env.append_value('CXXFLAGS_PYEXT','-fno-strict-aliasing')

    ## Check for pybindgen

    no_net = False
    if Params.g_options.with_pybindgen:
        conf.env['WITH_PYBINDGEN'] = os.path.abspath(Params.g_options.with_pybindgen)
        no_net = True

    if Params.g_options.pybindgen_checkout:
        fetch_pybindgen(conf)

    set_pybindgen_pythonpath(conf.env)

    try:
        conf.check_python_module('pybindgen')
    except Configure.ConfigurationError:
        warning("pybindgen missing")
        if no_net or not fetch_pybindgen(conf):
            conf.report_optional_feature("python", "Python Bindings", False,
                                         "PyBindGen missing and could not be retrieved")
            return

            warning("pybindgen (found %s) is too old (need %s)" %
                    (pybindgen_version_str,
                     '.'.join([str(x) for x in REQUIRED_PYBINDGEN_VERSION])))
            if no_net or not fetch_pybindgen(conf):
                conf.report_optional_feature("python", "Python Bindings", False,
                                             "PyBindGen too old and newer version could not be retrieved")
                return


    env = bld.env_of_name('default')
    curdir = bld.m_curdirnode.abspath()

    set_pybindgen_pythonpath(env)

    #Object.register('all-ns3-headers', AllNs3Headers)
    Action.Action('gen-ns3-metaheader', func=gen_ns3_metaheader, color='BLUE')





### Regression testing
class Regression(object):
    def __init__(self, testdir, reference_traces):
        self.testdir = testdir
        self.reference_traces = reference_traces
        self.env = Params.g_build.env_of_name('default')

    def run_test(self, verbose, generate, testName, arguments=[], pyscript=None, refTestName=None):
        """
        @param verbose: enable verbose execution

        @param generate: generate new traces instead of comparing with the reference

        @param refDirName: name of the base directory containing reference traces

        @param testName: name of the test


            raise TypeError
        
        if refTestName is None:
            refTestDirName = os.path.join(self.reference_traces, (testName + ".ref"))
        else:
            refTestDirName = os.path.join(self.reference_traces, refTestName)

        if not os.path.exists(self.reference_traces):
            print"No reference trace repository"
            return 1


                    tmpl = tmpl + " " + arg
                wutils.run_program(testName, tmpl)
            else:
                argv = [self.env['PYTHON'], os.path.join(Params.g_cwd_launch, *os.path.split(pyscript))] + arguments
                before = os.getcwd()
                os.chdir(refTestDirName)
                try:

    tests.sort()
    return tests

def run_regression(reference_traces):
    """Execute regression tests.  Called with cwd set to the 'regression' subdir of ns-3.

    @param reference_traces: reference traces directory, or None for default.

    """

    testdir = "tests"
    if not os.path.exists(testdir):
        print "Tests directory does not exist"
        sys.exit(3)

    dir_name = (wutils.APPNAME + '-' + wutils.VERSION + REGRESSION_SUFFIX)
    if reference_traces is None:
        reference_traces = dir_name
        no_net = False
    else:
        no_net = True
    
    sys.path.append(testdir)
    sys.modules['tracediff'] = Regression(testdir, reference_traces)

    if Params.g_options.regression_tests:
        tests = Params.g_options.regression_tests.split(',')

        tests = _find_tests(testdir)

    print "========== Running Regression Tests =========="
    dir_name = wutils.APPNAME + '-' + wutils.VERSION + REGRESSION_SUFFIX
    env = Params.g_build.env_of_name('default')
    if not no_net:
        if env['MERCURIAL']:
            print "Synchronizing reference traces using Mercurial."
            if not os.path.exists(reference_traces):
                print "Cloning " + REGRESSION_TRACES_REPO + dir_name + " from repo."
                argv = ["hg", "clone", REGRESSION_TRACES_REPO + dir_name, reference_traces]
                rv = subprocess.Popen(argv).wait()
            else:
                _dir = os.getcwd()
                os.chdir(reference_traces)
                try:
                    print "Pulling " + REGRESSION_TRACES_REPO + dir_name + " from repo."
                    result = subprocess.Popen(["hg", "-q", "pull", REGRESSION_TRACES_REPO + dir_name]).wait()
                    if not result:
                        result = subprocess.Popen(["hg", "-q", "update"]).wait()
                finally:
                    os.chdir("..")
                if result:
                    Params.fatal("Synchronizing reference traces using Mercurial failed.")
        else:
            if not os.path.exists(reference_traces):
                traceball = dir_name + wutils.TRACEBALL_SUFFIX
                print "Retrieving " + traceball + " from web."
                urllib.urlretrieve(REGRESSION_TRACES_URL + traceball, traceball)
                os.system("tar -xjf %s -C .." % (traceball))
                print "Done."
                    result = subprocess.Popen(["hg", "-q", "update"]).wait()
            finally:
                os.chdir("..")
            if result:
                Params.fatal("Synchronizing reference traces using Mercurial failed.")
    else:
        if not os.path.exists(dir_name):
            traceball = dir_name + wutils.TRACEBALL_SUFFIX
            print "Retrieving " + traceball + " from web."
            urllib.urlretrieve(REGRESSION_TRACES_URL + traceball, traceball)
            os.system("tar -xjf %s -C .." % (traceball))
            print "Done."

    if not os.path.exists(reference_traces):
        print "Reference traces directory (%s) does not exist" % reference_traces
        return 3
    
    bad = []

    else:
        os.mkdir("traces")
    
    dir_name = wutils.APPNAME + '-' + wutils.VERSION + REGRESSION_SUFFIX

    mod = __import__(test, globals(), locals(), [])
    return mod.run(verbose=(Params.g_options.verbose > 0),
                   generate=Params.g_options.regression_generate)


(-)a/regression/tests/test-csma-bridge.py (-2 / +2 lines)

Lines 6-15 import sys	Link Here

import sys

import sys

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    if tracediff.env['ENABLE_PYTHON_BINDINGS']:

    if tracediff.env['ENABLE_PYTHON_BINDINGS']:

        return tracediff.run_test(verbose, generate, refDirName,

        return tracediff.run_test(verbose, generate,

                                  "csma-bridge", pyscript=os.path.join('examples', 'csma-bridge.py'))

                                  "csma-bridge", pyscript=os.path.join('examples', 'csma-bridge.py'))

    else:

    else:

        print >> sys.stderr, "Skipping csma-bridge: Python bindings not available."

        print >> sys.stderr, "Skipping csma-bridge: Python bindings not available."

(-)a/regression/tests/test-csma-broadcast.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-broadcast")

    return tracediff.run_test(verbose, generate, "csma-broadcast")

(-)a/regression/tests/test-csma-multicast.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-multicast")

    return tracediff.run_test(verbose, generate, "csma-multicast")

(-)a/regression/tests/test-csma-one-subnet.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-one-subnet")

    return tracediff.run_test(verbose, generate, "csma-one-subnet")

(-)a/regression/tests/test-csma-packet-socket.py (-2 / +2 lines)

Lines 6-13 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        "csma-packet-socket")

        "csma-packet-socket")

(-)a/regression/tests/test-csma-ping.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-ping")

    return tracediff.run_test(verbose, generate, "csma-ping")

(-)a/regression/tests/test-csma-raw-ip-socket.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-raw-ip-socket")

    return tracediff.run_test(verbose, generate, "csma-raw-ip-socket")

(-)a/regression/tests/test-csma-star.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "csma-star")

    return tracediff.run_test(verbose, generate, "csma-star")

(-)a/regression/tests/test-realtime-udp-echo.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "realtime-udp-echo")

    return tracediff.run_test(verbose, generate, "realtime-udp-echo")

(-)a/regression/tests/test-simple-error-model.py (-2 / +2 lines)

Lines 6-13 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        "simple-error-model")

        "simple-error-model")

(-)a/regression/tests/test-simple-global-routing.py (-2 / +2 lines)

Lines 6-13 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        "simple-global-routing")

        "simple-global-routing")

(-)a/regression/tests/test-simple-point-to-point-olsr.py (-2 / +2 lines)

Lines 6-13 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        "simple-point-to-point-olsr")

        "simple-point-to-point-olsr")

(-)a/regression/tests/test-tcp-large-transfer.py (-2 / +2 lines)

Lines 6-13 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        "tcp-large-transfer")

        "tcp-large-transfer")

(-)a/regression/tests/test-tcp-nsc-lfn.py (-2 / +2 lines)

Lines 9-15 import platform	Link Here

import platform

import platform

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Run a Network Simulation Cradle test involving two TCP streams."""

    """Run a Network Simulation Cradle test involving two TCP streams."""

    if not tracediff.env['ENABLE_NSC']:

    if not tracediff.env['ENABLE_NSC']:

Lines 29-33 def run(verbose, generate, refDirName):	Link Here

        # string might not be the best idea?

        # string might not be the best idea?

        raise "Unknown architecture, not 64 or 32 bit?"

        raise "Unknown architecture, not 64 or 32 bit?"

    return tracediff.run_test(verbose, generate, refDirName,

    return tracediff.run_test(verbose, generate,

        testName, arguments=arguments, refTestName=traceDirName)

        testName, arguments=arguments, refTestName=traceDirName)

(-)a/regression/tests/test-udp-echo.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    #print tracediff.env

    #print tracediff.env

    return tracediff.run_test(verbose, generate, refDirName, "udp-echo")

    return tracediff.run_test(verbose, generate, "udp-echo")

(-)a/regression/tests/test-wifi-wired-bridging.py (-2 / +2 lines)

Lines 6-12 import shutil	Link Here

import shutil

import shutil

import tracediff

import tracediff

def run(verbose, generate, refDirName):

def run(verbose, generate):

    """Execute a test."""

    """Execute a test."""

    return tracediff.run_test(verbose, generate, refDirName, "wifi-wired-bridging", ["--SendIp=0"])

    return tracediff.run_test(verbose, generate, "wifi-wired-bridging", ["--SendIp=0"])

(-)a/src/core/object.cc (-1 / +2 lines)

Lines 111-120 Object::DoGetObject (TypeId tid) const	Link Here

111

112

  NS_ASSERT (CheckLoose ());

112

  NS_ASSERT (CheckLoose ());

113

  const Object *currentObject = this;

113

  const Object *currentObject = this;

114

  TypeId objectTid = Object::GetTypeId ();

114

  do {

115

  do {

115

    NS_ASSERT (currentObject != 0);

116

    NS_ASSERT (currentObject != 0);

116

    TypeId cur = currentObject->GetInstanceTypeId ();

117

    TypeId cur = currentObject->GetInstanceTypeId ();

117

    while (cur != tid && cur != Object::GetTypeId ())

118

    while (cur != tid && cur != objectTid)

118

119

        cur = cur.GetParent ();

120

        cur = cur.GetParent ();

120

121




 *         The TypeId class
 *********************************************************************/

TypeId::TypeId ()
  : m_tid (0)
{}

TypeId::TypeId (const char *name)
{
  uint16_t uid = Singleton<IidManager>::Get ()->AllocateUid (name);


TypeId::TypeId (uint16_t tid)
  : m_tid (tid)
{}
TypeId::~TypeId ()
{}
TypeId 
TypeId::LookupByName (std::string name)


ATTRIBUTE_HELPER_CPP (TypeId);

bool operator == (TypeId a, TypeId b)
{
  return a.m_tid == b.m_tid;
}

bool operator != (TypeId a, TypeId b)
{
  return a.m_tid != b.m_tid;
}

bool operator < (TypeId a, TypeId b)
{
  return a.m_tid < b.m_tid;

(-)a/src/core/type-id.h (-4 / +28 lines)

Lines 351-358 public:	Link Here

351

  void SetUid (uint16_t tid);

351

  void SetUid (uint16_t tid);

352

353

  // construct an invalid TypeId.

353

  // construct an invalid TypeId.

354

  TypeId ();

354

  inline TypeId ();

355

  ~TypeId ();

355

  inline TypeId (const TypeId &o);

356

  inline TypeId &operator = (const TypeId &o);

357

  inline ~TypeId ();

356

358

357

private:

359

private:

358

  friend class AttributeList;

360

  friend class AttributeList;

Lines 377-384 private:	Link Here

377

379

378

std::ostream & operator << (std::ostream &os, TypeId tid);

380

std::ostream & operator << (std::ostream &os, TypeId tid);

379

std::istream & operator >> (std::istream &is, TypeId &tid);

381

std::istream & operator >> (std::istream &is, TypeId &tid);

380

bool operator == (TypeId a, TypeId b);

382

inline bool operator == (TypeId a, TypeId b);

381

bool operator != (TypeId a, TypeId b);

383

inline bool operator != (TypeId a, TypeId b);

382

bool operator <  (TypeId a, TypeId b);

384

bool operator <  (TypeId a, TypeId b);

383

385

384

/**

386

/**

Lines 392-397 ATTRIBUTE_HELPER_HEADER (TypeId);	Link Here

392

} // namespace ns3

394

} // namespace ns3

393

395

394

namespace ns3 {

396

namespace ns3 {

397

398

TypeId::TypeId ()

399

  : m_tid (0) {}

400

TypeId::TypeId (const TypeId &o)

401

  : m_tid (o.m_tid) {}

402

TypeId &TypeId::operator = (const TypeId &o)

403

404

  m_tid = o.m_tid;

405

  return *this;

406

407

TypeId::~TypeId ()

408

{}

409

inline bool operator == (TypeId a, TypeId b)

410

411

  return a.m_tid == b.m_tid;

412

413

414

inline bool operator != (TypeId a, TypeId b)

415

416

  return a.m_tid != b.m_tid;

417

418

395

419

396

/*************************************************************************

420

/*************************************************************************

397

 *   The TypeId implementation which depends on templates

421

 *   The TypeId implementation which depends on templates

(-)a/src/internet-stack/ipv4-l3-protocol.cc (-6 / +31 lines)

Lines 669-676 Ipv4L3Protocol::Send (Ptr<Packet> packet	Link Here

669

          else

669

          else

670

671

              NS_ASSERT (packetCopy->GetSize () <= outInterface->GetMtu ());

671

              NS_ASSERT (packetCopy->GetSize () <= outInterface->GetMtu ());

672

              m_txTrace (packetCopy, ifaceIndex);

672

              if (outInterface->IsUp ())

673

              outInterface->Send (packetCopy, destination);

673

674

                  m_txTrace (packetCopy, ifaceIndex);

675

                  outInterface->Send (packetCopy, destination);

676

677

              else

678

679

                  m_dropTrace (packetCopy);

680

674

681

675

682

676

683

Lines 732-744 Ipv4L3Protocol::SendRealOut (bool found,	Link Here

732

      m_txTrace (packet, route.GetInterface ());

739

      m_txTrace (packet, route.GetInterface ());

733

      if (route.IsGateway ())

740

      if (route.IsGateway ())

734

741

735

          NS_LOG_LOGIC ("Send to gateway " << route.GetGateway ());

742

          if (outInterface->IsUp ())

736

          outInterface->Send (packet, route.GetGateway ());

743

744

              NS_LOG_LOGIC ("Send to gateway " << route.GetGateway ());

745

              m_txTrace (packet, route.GetInterface ());

746

              outInterface->Send (packet, route.GetGateway ());

747

748

          else

749

750

              NS_LOG_LOGIC ("Dropping-- outgoing interface is down: " << route.GetGateway ());

751

              m_dropTrace (packet);

752

737

753

738

      else

754

      else

739

755

740

          NS_LOG_LOGIC ("Send to destination " << ipHeader.GetDestination ());

756

          if (outInterface->IsUp ())

741

          outInterface->Send (packet, ipHeader.GetDestination ());

757

758

              NS_LOG_LOGIC ("Send to destination " << ipHeader.GetDestination ());

759

              m_txTrace (packet, route.GetInterface ());

760

              outInterface->Send (packet, ipHeader.GetDestination ());

761

762

          else

763

764

              NS_LOG_LOGIC ("Dropping-- outgoing interface is down: " << route.GetGateway ());

765

              m_dropTrace (packet);

766

742

767

743

768

744

769

(-)a/src/internet-stack/wscript (-1 / +1 lines)

Lines 7-13 import urllib	Link Here

# Mercurial repository of the network simulation cradle

# Mercurial repository of the network simulation cradle

NSC_REPO = "https://secure.wand.net.nz/mercurial/nsc"

NSC_REPO = "https://secure.wand.net.nz/mercurial/nsc"

NSC_RELEASE_URL = "http://research.wand.net.nz/software/nsc"

NSC_RELEASE_URL = "http://research.wand.net.nz/software/nsc"

NSC_RELEASE_NAME = "nsc-0.4.0"

NSC_RELEASE_NAME = "nsc-0.5.0"

# directory that contains network simulation cradle source

# directory that contains network simulation cradle source

# note, this path is relative to the project root

# note, this path is relative to the project root

(-)a/wscript (-1 / +14 lines)

Lines 143-148 def set_options(opt):	Link Here

143

                   help=('Use sudo to setup suid bits on ns3 executables.'),

143

                   help=('Use sudo to setup suid bits on ns3 executables.'),

144

                   dest='enable_sudo', action='store_true',

144

                   dest='enable_sudo', action='store_true',

145

                   default=False)

145

                   default=False)

146

    opt.add_option('--with-regression-traces',

147

                   help=('Path to the regression reference traces directory'),

148

                   default=None,

149

                   dest='regression_traces', type="string")

146

150

147

    # options provided in a script in a subdirectory named "src"

151

    # options provided in a script in a subdirectory named "src"

148

    opt.sub_options('src')

152

    opt.sub_options('src')

Lines 192-197 def configure(conf):	Link Here

192

        variant_name = debug_level

196

        variant_name = debug_level

193

197

194

    variant_env['INCLUDEDIR'] = os.path.join(variant_env['PREFIX'], 'include')

198

    variant_env['INCLUDEDIR'] = os.path.join(variant_env['PREFIX'], 'include')

199

200

    if Params.g_options.regression_traces is not None:

201

        variant_env['REGRESSION_TRACES'] = os.path.join("..", Params.g_options.regression_traces)

202

    else:

203

        variant_env['REGRESSION_TRACES'] = None

195

204

196

    if Params.g_options.enable_gcov:

205

    if Params.g_options.enable_gcov:

197

        variant_name += '-gcov'

206

        variant_name += '-gcov'

Lines 463-472 def shutdown():	Link Here

463

    if Params.g_options.regression or Params.g_options.regression_generate:

472

    if Params.g_options.regression or Params.g_options.regression_generate:

464

        if not env['DIFF']:

473

        if not env['DIFF']:

465

            Params.fatal("Cannot run regression tests: the 'diff' program is not installed.")

474

            Params.fatal("Cannot run regression tests: the 'diff' program is not installed.")

475

466

        _dir = os.getcwd()

476

        _dir = os.getcwd()

467

        os.chdir("regression")

477

        os.chdir("regression")

478

        regression_traces = env['REGRESSION_TRACES']

479

        if not regression_traces:

480

            regression_traces = None

468

        try:

481

        try:

469

            regression.run_regression()

482

            regression.run_regression(regression_traces)

470

        finally:

483

        finally:

471

            os.chdir(_dir)

484

            os.chdir(_dir)

472

485





      if (!isIp)
        {
          NS_LOG_LOGIC ("Net device " << ndLocal << "has no IP interface, skipping");
          continue;
        }


      //
      if (ndLocal->IsBroadcast () && !ndLocal->IsPointToPoint () )
        {
          NS_LOG_LOGIC ("Broadcast link");
          ProcessBroadcastLink (ndLocal, pLSA, c);
        }
      else if (ndLocal->IsPointToPoint () )
        {
          NS_LOG_LOGIC ("Point=to-point link");
          ProcessPointToPointLink (ndLocal, pLSA);
        }
      else

      //
      // This is a net device connected to a stub network
      //
      NS_LOG_LOGIC("Router-LSA Stub Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

      // 

      // We have multiple routers on a broadcast interface, so this is
      // a transit network.
      //
      NS_LOG_LOGIC ("Router-LSA Transit Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

      // 

      //
      // This is a net device connected to a bridge of stub networks
      //
      NS_LOG_LOGIC("Router-LSA Stub Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::StubNetwork);

      // 

      // We have multiple routers on a bridged broadcast interface, so this is
      // a transit network.
      //
      NS_LOG_LOGIC ("Router-LSA Transit Network");
      plr->SetLinkType (GlobalRoutingLinkRecord::TransitNetwork);

      // 

  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  NS_LOG_LOGIC ("Looking for designated router off of net device " << ndLocal << " on node " << 
                ndLocal->GetNode ()->GetId ());

  Ipv4Address desigRtr ("255.255.255.255");


      Ptr<Node> nodeOther = ndOther->GetNode ();

      NS_LOG_LOGIC ("Examine channel device " << i << " on node " << nodeOther->GetId ());

      //
      // For all other net devices, we need to check and see if a router

      // device, we need to consider all of the other devices on the 
      // bridge as well (all of the bridge ports.
      //
      NS_LOG_LOGIC ("checking to see if the device is bridged");
      Ptr<BridgeNetDevice> bnd = NetDeviceIsBridged (ndOther);
      if (bnd)
        {
          NS_LOG_LOGIC ("Device is bridged by BridgeNetDevice " << bnd);

          //
          // It is possible that the bridge net device is sitting under a

          // an internet stack that includes the Ipv4 interface.  If it doesn't
          // it can't play router.
          //
          NS_LOG_LOGIC ("Checking for router on bridge net device " << bnd);
          Ptr<GlobalRouter> rtr = nodeOther->GetObject<GlobalRouter> ();
          Ptr<Ipv4> ipv4 = nodeOther->GetObject<Ipv4> ();
          if (rtr && ipv4)

              uint32_t ifIndexOther;
              if (FindIfIndexForDevice(nodeOther, bnd, ifIndexOther))
                {
                  NS_LOG_LOGIC ("Found router on bridge net device " << bnd);
                  Ipv4Address addrOther = ipv4->GetAddress (ifIndexOther);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("designated router now " << desigRtr);
                }
            }

          NS_LOG_LOGIC ("Looking through bridge ports of bridge net device " << bnd);
          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              Ptr<NetDevice> ndBridged = bnd->GetBridgePort (j);
              NS_LOG_LOGIC ("Examining bridge port " << j << " device " << ndBridged);
              if (ndBridged == ndOther)
                {
                  NS_LOG_LOGIC ("That bridge port is me, don't walk backward");
                  continue;
                }

              if (allowRecursion)
                {
                  NS_LOG_LOGIC ("Recursively looking for routers down bridge port " << ndBridged);
                  Ipv4Address addrOther = FindDesignatedRouterForLink (ndBridged, false);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("designated router now " << desigRtr);
                }
            }
        }
      else
        {
          NS_LOG_LOGIC ("This device is not bridged");
          Ptr<Node> nodeOther = ndOther->GetNode ();
          NS_ASSERT (nodeOther);


              uint32_t ifIndexOther;
              if (FindIfIndexForDevice(nodeOther, ndOther, ifIndexOther))
                {
                  NS_LOG_LOGIC ("Found router on net device " << ndOther);
                  Ipv4Address addrOther = ipv4->GetAddress (ifIndexOther);
                  desigRtr = addrOther < desigRtr ? addrOther : desigRtr;
                  NS_LOG_LOGIC ("designated router now " << desigRtr);
                }
            }
        }

  uint32_t nDevices = ch->GetNDevices();
  NS_ASSERT (nDevices);

  NS_LOG_LOGIC ("Looking for routers off of net device " << nd << " on node " << nd->GetNode ()->GetId ());

  //
  // Look through all of the devices on the channel to which the net device

      Ptr<NetDevice> ndOther = ch->GetDevice (i);
      NS_ASSERT (ndOther);

      NS_LOG_LOGIC ("Examine channel device " << i << " on node " << ndOther->GetNode ()->GetId ());

      // 
      // Ignore the net device itself.
      //
      if (ndOther == nd)
        {
          NS_LOG_LOGIC ("Myself, skip");
          continue;
        }


      // device, we need to consider all of the other devices on the 
      // bridge.
      //
      NS_LOG_LOGIC ("checking to see if device is bridged");
      Ptr<BridgeNetDevice> bnd = NetDeviceIsBridged (ndOther);
      if (bnd)
        {
          NS_LOG_LOGIC ("Device is bridged by net device " << bnd);
          NS_LOG_LOGIC ("Looking through bridge ports of bridge net device " << bnd);
          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              Ptr<NetDevice> ndBridged = bnd->GetBridgePort (j);
              NS_LOG_LOGIC ("Examining bridge port " << j << " device " << ndBridged);
              if (ndBridged == ndOther)
                {
                  NS_LOG_LOGIC ("That bridge port is me, skip");
                  continue;
                }

              if (allowRecursion)
                {
                  NS_LOG_LOGIC ("Recursively looking for routers on bridge port " << ndBridged);
                  if (AnotherRouterOnLink (ndBridged, false))
                    {
                      NS_LOG_LOGIC ("Found routers on bridge port, return true");
                      return true;
                    }
                }
            }
          NS_LOG_LOGIC ("No routers on bridged net device, return false");
          return false;
        }

      NS_LOG_LOGIC ("This device is not bridged");
      Ptr<Node> nodeTemp = ndOther->GetNode ();
      NS_ASSERT (nodeTemp);

      Ptr<GlobalRouter> rtr = nodeTemp->GetObject<GlobalRouter> ();
      if (rtr)
        {
          NS_LOG_LOGIC ("Found GlobalRouter interface, return true");
          return true;
        }
      else 
        {
          NS_LOG_LOGIC ("No GlobalRouter interface on device, continue search");
        }
    }
  NS_LOG_LOGIC ("No routers found, return false");
  return false;
}


  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
  if (ipv4 == 0)
    {
      NS_LOG_LOGIC ("No Ipv4 interface on node " << node->GetId ());
      return false;
    }


    {
      if (ipv4->GetNetDevice(i) == nd) 
        {
          NS_LOG_LOGIC ("Device " << nd << " has associated ipv4 index " << i);
          index = i;
          return true;
        }
    }

  NS_LOG_LOGIC ("Device " << nd << " has no associated ipv4 index");
  return false;
}


  for (uint32_t i = 0; i < nDevices; ++i)
    {
      Ptr<NetDevice> ndTest = node->GetDevice(i);
      NS_LOG_LOGIC ("Examine device " << i << " " << ndTest);

      if (ndTest->IsBridge ())
        {
          NS_LOG_LOGIC ("device " << i << " is a bridge net device");
          Ptr<BridgeNetDevice> bnd = ndTest->GetObject<BridgeNetDevice> ();
          NS_ABORT_MSG_UNLESS (bnd, "GlobalRouter::DiscoverLSAs (): GetObject for <BridgeNetDevice> failed");

          for (uint32_t j = 0; j < bnd->GetNBridgePorts (); ++j)
            {
              NS_LOG_LOGIC ("Examine bridge port " << j << " " << bnd->GetBridgePort (j));
              if (bnd->GetBridgePort (j) == nd)
                {
                  NS_LOG_LOGIC ("Net device " << nd << " is bridged by " << bnd);
                  return bnd;
                }
            }
        }
    }
  NS_LOG_LOGIC ("Net device " << nd << " is not bridged");
  return 0;
}


Return to bug 114