Attachment #491 for bug #600

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




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

using namespace ns3;


  BridgeHelper bridge;
  bridge.Install (bridge1, topBridgeDevices);

  // Add internet stack to the router nodes
  NodeContainer routerNodes (n0, n1, n2, n3, n4);
  InternetStackHelper internet;
  internet.Install (routerNodes);

  // Repeat for bottom bridged LAN
  NetDeviceContainer bottomLanDevices;

    }
  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;

  // tables in the nodes.  We excuse the bridge nodes from having to serve as
  // routers, since they don't even have internet stacks on them.
  //
  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
  GlobalRouteManager::PopulateRoutingTables (routerNodes);

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

(-)a/examples/csma-ping.cc (-2 / +1 lines)

Lines 37-43	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 85-91	Link Here

  Ipv4InterfaceContainer addresses = ip.Assign (devs);

  Ipv4InterfaceContainer addresses = ip.Assign (devs);

  // setup global router

  // setup global router

  GlobalRouteManager::PopulateRoutingTables ();

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

  NS_LOG_INFO ("Create Source");

  NS_LOG_INFO ("Create Source");

  Config::SetDefault ("ns3::Ipv4RawSocketImpl::Protocol", StringValue ("2"));

  Config::SetDefault ("ns3::Ipv4RawSocketImpl::Protocol", StringValue ("2"));

  InetSocketAddress dst = InetSocketAddress (addresses.GetAddress (3));

  InetSocketAddress dst = InetSocketAddress (addresses.GetAddress (3));

(-)a/examples/csma-star.cc (-2 / +1 lines)

Lines 20-26	Link Here

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/csma-module.h"

#include "ns3/csma-module.h"

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

// Network topology (default)

// Network topology (default)

//

//

Lines 196-202	Link Here

196

//

195

//

197

  // Turn on global static routing so we can actually be routed across the star.

196

  // Turn on global static routing so we can actually be routed across the star.

198

//

197

//

199

  GlobalRouteManager::PopulateRoutingTables ();

198

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

200

199

201

  NS_LOG_INFO ("Enable pcap tracing.");

200

  NS_LOG_INFO ("Enable pcap tracing.");

202

//

201

//




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

using namespace ns3;



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

  // Create the OnOff application to send UDP datagrams of size
  // 210 bytes at a rate of 448 Kb/s

  uint32_t ipv4ifIndex1 = 2;

  Simulator::Schedule (Seconds (2),&Ipv4::SetDown,ipv41, ipv4ifIndex1);
  Simulator::Schedule (Seconds (3),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);
  Simulator::Schedule (Seconds (4),&Ipv4::SetUp,ipv41, ipv4ifIndex1);
  Simulator::Schedule (Seconds (5),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);

  Ptr<Node> n6 = c.Get (6);
  Ptr<Ipv4> ipv46 = n6->GetObject<Ipv4> ();

  // then the next p2p is numbered 2
  uint32_t ipv4ifIndex6 = 2;
  Simulator::Schedule (Seconds (6),&Ipv4::SetDown,ipv46, ipv4ifIndex6);
  Simulator::Schedule (Seconds (7),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);
  Simulator::Schedule (Seconds (8),&Ipv4::SetUp,ipv46, ipv4ifIndex6);
  Simulator::Schedule (Seconds (9),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);

  Simulator::Schedule (Seconds (12),&Ipv4::SetDown,ipv41, ipv4ifIndex1);
  Simulator::Schedule (Seconds (13),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);
  Simulator::Schedule (Seconds (14),&Ipv4::SetUp,ipv41, ipv4ifIndex1);
  Simulator::Schedule (Seconds (15),&Ipv4GlobalRoutingHelper::RecomputeRoutingTables);

  NS_LOG_INFO ("Run Simulation.");
  Simulator::Run ();

(-)a/examples/global-routing-slash32.cc (-2 / +1 lines)

Lines 29-35	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 99-105	Link Here

100

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

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

101

  // tables in the nodes.

100

  // tables in the nodes.

102

  GlobalRouteManager::PopulateRoutingTables ();

101

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

103

102

104

  // Create the OnOff application to send UDP datagrams of size

103

  // Create the OnOff application to send UDP datagrams of size

105

  // 210 bytes at a rate of 448 Kb/s

104

  // 210 bytes at a rate of 448 Kb/s

(-)a/examples/mixed-global-routing.cc (-2 / +1 lines)

Lines 40-46	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 104-110	Link Here

104

103

105

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

104

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

106

  // tables in the nodes.

105

  // tables in the nodes.

107

  GlobalRouteManager::PopulateRoutingTables ();

106

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

108

107

109

  // Create the OnOff application to send UDP datagrams of size

108

  // Create the OnOff application to send UDP datagrams of size

110

  // 210 bytes at a rate of 448 Kb/s

109

  // 210 bytes at a rate of 448 Kb/s

(-)a/examples/mixed-wireless.cc (-8 / +11 lines)

Lines 67-73	Link Here

#include "ns3/mobility-module.h"

#include "ns3/mobility-module.h"

#include "ns3/contrib-module.h"

#include "ns3/contrib-module.h"

#include "ns3/wifi-module.h"

#include "ns3/wifi-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 152-162	Link Here

152

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

151

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

153

  wifiPhy.SetChannel (wifiChannel.Create ());

152

  wifiPhy.SetChannel (wifiChannel.Create ());

154

  NetDeviceContainer backboneDevices = wifi.Install (wifiPhy, mac, backbone);

153

  NetDeviceContainer backboneDevices = wifi.Install (wifiPhy, mac, backbone);

154

155

  // We enable OLSR (which will be consulted at a higher priority than

156

  // the global routing) on the backbone ad hoc nodes

157

  NS_LOG_INFO ("Enabling OLSR routing on all backbone nodes");

158

  OlsrHelper olsr;

155

//

159

//

156

  // Add the IPv4 protocol stack to the nodes in our container

160

  // Add the IPv4 protocol stack to the nodes in our container

157

//

161

//

158

  InternetStackHelper internet;

162

  InternetStackHelper internet;

163

  internet.SetRoutingHelper (olsr);

159

  internet.Install (backbone);

164

  internet.Install (backbone);

165

166

  // re-initialize for non-olsr routing.

167

  internet = InternetStackHelper ();

168

160

//

169

//

161

  // Assign IPv4 addresses to the device drivers (actually to the associated

170

  // Assign IPv4 addresses to the device drivers (actually to the associated

162

  // IPv4 interfaces) we just created.

171

  // IPv4 interfaces) we just created.

Lines 322-334	Link Here

322

  // However, it is useful for setting default routes for all of the nodes

331

  // However, it is useful for setting default routes for all of the nodes

323

  // such as the LAN nodes.

332

  // such as the LAN nodes.

324

  NS_LOG_INFO ("Enabling global routing on all nodes");

333

  NS_LOG_INFO ("Enabling global routing on all nodes");

325

  GlobalRouteManager::PopulateRoutingTables ();

334

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

326

327

  // We enable OLSR (which will be consulted at a higher priority than

328

  // the global routing above) on the backbone ad hoc nodes

329

  NS_LOG_INFO ("Enabling OLSR routing on all backbone nodes");

330

  OlsrHelper olsr;

331

  olsr.Install (backbone);

332

335

333

  ///////////////////////////////////////////////////////////////////////////

336

  ///////////////////////////////////////////////////////////////////////////

334

  //                                                                       //

337

  //                                                                       //

(-)a/examples/second.cc (-2 / +1 lines)

Lines 18-24	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/global-routing-module.h"

// Default Network Topology

// Default Network Topology

//

//

Lines 102-108	Link Here

102

  clientApps.Start (Seconds (2.0));

101

  clientApps.Start (Seconds (2.0));

103

  clientApps.Stop (Seconds (10.0));

102

  clientApps.Stop (Seconds (10.0));

104

103

105

  GlobalRouteManager::PopulateRoutingTables ();

104

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

106

105

107

  PointToPointHelper::EnablePcapAll ("second");

106

  PointToPointHelper::EnablePcapAll ("second");

108

  CsmaHelper::EnablePcap ("second", csmaDevices.Get (1), true);

107

  CsmaHelper::EnablePcap ("second", csmaDevices.Get (1), true);




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

using namespace ns3;


  // Users may find it convenient to turn on explicit debugging
  // for selected modules; the below lines suggest how to do this
#if 0 
  LogComponentEnable("GlobalRoutingHelper", LOG_LOGIC);
  LogComponentEnable("GlobalRouter", LOG_LOGIC);
#endif



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

  // Create the OnOff application to send UDP datagrams 
  NS_LOG_INFO ("Create Application.");

(-)a/examples/simple-error-model.cc (-2 / +1 lines)

Lines 44-50	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 111-117	Link Here

111

  Ipv4InterfaceContainer i3i2 = ipv4.Assign (d3d2);

110

  Ipv4InterfaceContainer i3i2 = ipv4.Assign (d3d2);

112

111

113

  NS_LOG_INFO ("Use global routing.");

112

  NS_LOG_INFO ("Use global routing.");

114

  GlobalRouteManager::PopulateRoutingTables ();

113

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

115

114

116

  // Create the OnOff application to send UDP datagrams of size

115

  // Create the OnOff application to send UDP datagrams of size

117

  // 210 bytes at a rate of 448 Kb/s

116

  // 210 bytes at a rate of 448 Kb/s

(-)a/examples/simple-global-routing.cc (-2 / +1 lines)

Lines 46-52	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 111-117	Link Here

111

110

112

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

111

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

113

  // tables in the nodes.

112

  // tables in the nodes.

114

  GlobalRouteManager::PopulateRoutingTables ();

113

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

115

114

116

  // Create the OnOff application to send UDP datagrams of size

115

  // Create the OnOff application to send UDP datagrams of size

117

  // 210 bytes at a rate of 448 Kb/s

116

  // 210 bytes at a rate of 448 Kb/s




  NodeContainer n32 = NodeContainer (c.Get(3), c.Get (2));
  NodeContainer n34 = NodeContainer (c.Get (3), c.Get (4));

  // Enable OLSR
  NS_LOG_INFO ("Enabling OLSR Routing.");
  OlsrHelper olsr;

  Ipv4StaticRoutingHelper staticRouting;

  Ipv4ListRoutingHelper list;
  list.Add (staticRouting, 0);
  list.Add (olsr, 10);

  InternetStackHelper internet;
  internet.SetRoutingHelper (list);
  internet.Install (c);

  // We create the channels first without any IP addressing information

  ipv4.SetBase ("10.1.4.0", "255.255.255.0");
  Ipv4InterfaceContainer i34 = ipv4.Assign (nd34);

  // Enable OLSR
  NS_LOG_INFO ("Enabling OLSR Routing.");
  OlsrHelper olsr;
  olsr.InstallAll ();

  // Create the OnOff application to send UDP datagrams of size
  // 210 bytes at a rate of 448 Kb/s
  NS_LOG_INFO ("Create Applications.");

(-)a/examples/simple-wifi-frame-aggregation.cc (-2 / +1 lines)

Lines 21-27	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/global-routing-module.h"

#include "ns3/wifi-module.h"

#include "ns3/wifi-module.h"

#include "ns3/mobility-module.h"

#include "ns3/mobility-module.h"

Lines 137-143	Link Here

137

  clientApps.Start (Seconds (2.0));

136

  clientApps.Start (Seconds (2.0));

138

  clientApps.Stop (Seconds (10.0));

137

  clientApps.Stop (Seconds (10.0));

139

138

140

  GlobalRouteManager::PopulateRoutingTables ();

139

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

141

140

142

  Simulator::Stop (Seconds (10.0));

141

  Simulator::Stop (Seconds (10.0));

143

142

(-)a/examples/star.cc (-2 / +1 lines)

Lines 19-25	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

// Network topology (default)

// Network topology (default)

//

//

Lines 132-138	Link Here

132

//

131

//

133

  // Turn on global static routing so we can actually be routed across the star.

132

  // Turn on global static routing so we can actually be routed across the star.

134

//

133

//

135

  GlobalRouteManager::PopulateRoutingTables ();

134

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

136

135

137

  NS_LOG_INFO ("Enable pcap tracing.");

136

  NS_LOG_INFO ("Enable pcap tracing.");

138

//

137

//

(-)a/examples/tap-wifi-dumbbell.cc (-2 / +1 lines)

Lines 114-120	Link Here

114

#include "ns3/core-module.h"

114

#include "ns3/core-module.h"

115

#include "ns3/wifi-module.h"

115

#include "ns3/wifi-module.h"

116

#include "ns3/helper-module.h"

116

#include "ns3/helper-module.h"

117

#include "ns3/global-routing-module.h"

118

117

119

using namespace ns3;

118

using namespace ns3;

120

119

Lines 228-234	Link Here

228

  apps.Start (Seconds (1.0));

227

  apps.Start (Seconds (1.0));

229

228

230

  CsmaHelper::EnablePcapAll ("tap-wifi-dumbbell", false);

229

  CsmaHelper::EnablePcapAll ("tap-wifi-dumbbell", false);

231

  GlobalRouteManager::PopulateRoutingTables ();

230

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

232

231

233

  Simulator::Stop (Seconds (60.));

232

  Simulator::Stop (Seconds (60.));

234

  Simulator::Run ();

233

  Simulator::Run ();




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

using namespace ns3;

  NetDeviceContainer dev1 = p2p.Install (n1n2);

  // Now add ip/tcp stack to all nodes.
  NodeContainer allNodes = NodeContainer (n0n1, n1n2.Get (1));
  InternetStackHelper internet;
  internet.InstallAll ();

  // Later, we add IP addresses.
  Ipv4AddressHelper ipv4;

  Ipv4InterfaceContainer ipInterfs = ipv4.Assign (dev1);

  // and setup ip routing tables to get total ip-level connectivity.
  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

  ///////////////////////////////////////////////////////////////////////////
  // Simulation 1

(-)a/examples/tcp-nsc-lfn.cc (-2 / +1 lines)

Lines 36-42	Link Here

#include "ns3/common-module.h"

#include "ns3/common-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

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

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

using namespace ns3;

using namespace ns3;

Lines 117-123	Link Here

117

  p2pInterfaces.Get(0)->SetAttribute("ReceiveErrorModel", PointerValue (em1));

116

  p2pInterfaces.Get(0)->SetAttribute("ReceiveErrorModel", PointerValue (em1));

118

  p2pInterfaces.Get(1)->SetAttribute("ReceiveErrorModel", PointerValue (em2));

117

  p2pInterfaces.Get(1)->SetAttribute("ReceiveErrorModel", PointerValue (em2));

119

118

120

  GlobalRouteManager::PopulateRoutingTables ();

119

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

121

120

122

  uint16_t servPort = 8080;

121

  uint16_t servPort = 8080;

123

  PacketSinkHelper sinkHelper ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), servPort));

122

  PacketSinkHelper sinkHelper ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), servPort));




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

using namespace ns3;

  NetDeviceContainer ethInterfaces = csma.Install (n);

  InternetStackHelper internetStack;

  internetStack.SetTcp ("ns3::NscTcpL4Protocol","Library",StringValue("liblinux2.6.26.so"));
  // this switches nodes 0 and 1 to NSCs Linux 2.6.26 stack.
  internetStack.Install (n.Get(0));

  ipv4.SetBase ("10.0.0.0", "255.255.255.0");
  Ipv4InterfaceContainer ipv4Interfaces = ipv4.Assign (ethInterfaces);

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

  uint16_t servPort = 8080;
  PacketSinkHelper sinkHelper ("ns3::TcpSocketFactory", InetSocketAddress (Ipv4Address::GetAny (), servPort));

(-)a/examples/tcp-star-server.cc (-2 / +1 lines)

Lines 52-58	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

using namespace ns3;

using namespace ns3;

Lines 123-129	Link Here

123

122

124

123

125

  //Turn on global static routing

124

  //Turn on global static routing

126

  GlobalRouteManager::PopulateRoutingTables ();

125

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

127

126

128

  // Create a packet sink on the star "hub" to receive these packets

127

  // Create a packet sink on the star "hub" to receive these packets

129

  uint16_t port = 50000;

128

  uint16_t port = 50000;

(-)a/examples/third.cc (-2 / +1 lines)

Lines 18-24	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/global-routing-module.h"

#include "ns3/wifi-module.h"

#include "ns3/wifi-module.h"

#include "ns3/mobility-module.h"

#include "ns3/mobility-module.h"

Lines 159-165	Link Here

159

  clientApps.Start (Seconds (2.0));

158

  clientApps.Start (Seconds (2.0));

160

  clientApps.Stop (Seconds (10.0));

159

  clientApps.Stop (Seconds (10.0));

161

160

162

  GlobalRouteManager::PopulateRoutingTables ();

161

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

163

162

164

  Simulator::Stop (Seconds (10.0));

163

  Simulator::Stop (Seconds (10.0));

165

164

(-)a/examples/virtual-net-device.cc (-2 / +1 lines)

Lines 57-63	Link Here

#include "ns3/simulator-module.h"

#include "ns3/simulator-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

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

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

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

using namespace ns3;

using namespace ns3;

Lines 238-244	Link Here

238

237

239

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

238

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

240

  // tables in the nodes.

239

  // tables in the nodes.

241

  GlobalRouteManager::PopulateRoutingTables ();

240

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

242

241

243

  // Add the tunnels

242

  // Add the tunnels

244

  Tunnel tunnel (c.Get (3), c.Get (0), c.Get (1),

243

  Tunnel tunnel (c.Get (3), c.Get (0), c.Get (1),

(-)a/examples/wifi-wired-bridging.cc (-1 lines)

Lines 49-55	Link Here

#include "ns3/helper-module.h"

#include "ns3/helper-module.h"

#include "ns3/wifi-module.h"

#include "ns3/wifi-module.h"

#include "ns3/node-module.h"

#include "ns3/node-module.h"

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

#include <vector>

#include <vector>

#include <stdint.h>

#include <stdint.h>

#include <sstream>

#include <sstream>

(-)a/src/helper/internet-stack-helper.cc (-9 / +25 lines)

Lines 153-159	Link Here

153

#include "ns3/object.h"

153

#include "ns3/object.h"

154

#include "ns3/names.h"

154

#include "ns3/names.h"

155

#include "ns3/ipv4.h"

155

#include "ns3/ipv4.h"

156

#include "internet-stack-helper.h"

157

#include "ns3/packet-socket-factory.h"

156

#include "ns3/packet-socket-factory.h"

158

#include "ns3/config.h"

157

#include "ns3/config.h"

159

#include "ns3/simulator.h"

158

#include "ns3/simulator.h"

Lines 162-169	Link Here

162

#include "ns3/callback.h"

161

#include "ns3/callback.h"

163

#include "ns3/node.h"

162

#include "ns3/node.h"

164

#include "ns3/core-config.h"

163

#include "ns3/core-config.h"

165

#include "ns3/ipv4-list-routing.h"

164

#include "internet-stack-helper.h"

166

#include "ns3/ipv4-static-routing.h"

165

#include "ipv4-list-routing-helper.h"

166

#include "ipv4-static-routing-helper.h"

167

#include "ipv4-global-routing-helper.h"

167

#include <limits>

168

#include <limits>

168

169

namespace ns3 {

170

namespace ns3 {

Lines 174-179	Link Here

174

InternetStackHelper::InternetStackHelper ()

175

InternetStackHelper::InternetStackHelper ()

175

176

  SetTcp ("ns3::TcpL4Protocol");

177

  SetTcp ("ns3::TcpL4Protocol");

178

  static Ipv4StaticRoutingHelper staticRouting;

179

  static Ipv4GlobalRoutingHelper globalRouting;

180

  static Ipv4ListRoutingHelper listRouting;

181

  listRouting.Add (staticRouting, 0);

182

  listRouting.Add (globalRouting, -10);

183

  SetRoutingHelper (listRouting);

184

185

186

void

187

InternetStackHelper::SetRoutingHelper (const Ipv4RoutingHelper &routing)

188

189

  m_routing = &routing;

177

190

178

191

179

void

192

void

Lines 213-220	Link Here

213

226

214

227

215

228

216

static void

229

void

217

CreateAndAggregateObjectFromTypeId (Ptr<Node> node, const std::string typeId)

230

InternetStackHelper::InstallAll (void) const

231

232

  Install (NodeContainer::GetGlobal ());

233

234

235

void

236

InternetStackHelper::CreateAndAggregateObjectFromTypeId (Ptr<Node> node, const std::string typeId)

218

237

219

  ObjectFactory factory;

238

  ObjectFactory factory;

220

  factory.SetTypeId(typeId);

239

  factory.SetTypeId(typeId);

Lines 241-250	Link Here

241

  node->AggregateObject (factory);

260

  node->AggregateObject (factory);

242

  // Set routing

261

  // Set routing

243

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

262

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

244

  // XXX cut this over to use of TypeIds and factories

263

  Ptr<Ipv4RoutingProtocol> ipv4Routing = m_routing->Create (node);

245

  Ptr<Ipv4ListRouting> ipv4Routing = CreateObject<Ipv4ListRouting> ();

246

  Ptr<Ipv4StaticRouting> ipv4staticRouting = CreateObject<Ipv4StaticRouting> ();

247

  ipv4Routing->AddRoutingProtocol (ipv4staticRouting, 0);

248

  ipv4->SetRoutingProtocol (ipv4Routing);

264

  ipv4->SetRoutingProtocol (ipv4Routing);

249

265

250

266

(-)a/src/helper/internet-stack-helper.h (+28 lines)

Lines 31-36	Link Here

namespace ns3 {

namespace ns3 {

class Node;

class Node;

class Ipv4RoutingHelper;

/**

/**

 * \brief aggregate IP/TCP/UDP functionality to existing Nodes.

 * \brief aggregate IP/TCP/UDP functionality to existing Nodes.

Lines 38-46	Link Here

class InternetStackHelper

class InternetStackHelper

public:

public:

/**

   * Create a new InternetStackHelper which uses a mix of static routing

   * and global routing by default. The static routing protocol

   * (ns3::Ipv4StaticRouting) and the global routing protocol are

   * stored in an ns3::Ipv4ListRouting protocol with priorities 0, and -10

   * by default. If you wish to use different priorites and different

   * routing protocols, you need to use an adhoc ns3::Ipv4RoutingHelper,

   * such as ns3::OlsrHelper

*/

  InternetStackHelper(void);

  InternetStackHelper(void);

/**

/**

   * \param routing a new routing helper

   * Set the routing helper to use during Install. The routing

   * helper is really an object factory which is used to create

   * an object of type ns3::Ipv4RoutingProtocol per node. This routing

   * object is then associated to a single ns3::Ipv4 object through its

   * ns3::Ipv4::SetRoutingProtocol.

*/

  void SetRoutingHelper (const Ipv4RoutingHelper &routing);

/**

   * Aggregate implementations of the ns3::Ipv4, ns3::Udp, and ns3::Tcp classes

   * Aggregate implementations of the ns3::Ipv4, ns3::Udp, and ns3::Tcp classes

   * onto the provided node.  This method will assert if called on a node that

   * onto the provided node.  This method will assert if called on a node that

   * already has an Ipv4 object aggregated to it.

   * already has an Ipv4 object aggregated to it.

Lines 69-74	Link Here

*/

*/

  void Install (NodeContainer c) const;

  void Install (NodeContainer c) const;

/**

   * Aggregate ip, udp, and tcp stacks to all nodes in the simulation

*/

  void InstallAll (void) const;

/**

/**

   * \brief set the Tcp stack which will not need any other parameter.

   * \brief set the Tcp stack which will not need any other parameter.

100

Lines 132-137	Link Here

132

158

133

private:

159

private:

134

  ObjectFactory m_tcpFactory;

160

  ObjectFactory m_tcpFactory;

161

  const Ipv4RoutingHelper *m_routing;

162

  static void CreateAndAggregateObjectFromTypeId (Ptr<Node> node, const std::string typeId);

135

  static void Cleanup (void);

163

  static void Cleanup (void);

136

  static void LogRxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);

164

  static void LogRxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);

137

  static void LogTxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);

165

  static void LogTxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);




#include "ipv4-global-routing-helper.h"
#include "ns3/global-router-interface.h"
#include "ns3/ipv4-global-routing.h"
#include "ns3/ipv4-list-routing.h"
#include "ns3/log.h"

NS_LOG_COMPONENT_DEFINE("GlobalRoutingHelper");

namespace ns3 {

Ipv4GlobalRoutingHelper::Ipv4GlobalRoutingHelper ()
{}
Ptr<Ipv4RoutingProtocol> 
Ipv4GlobalRoutingHelper::Create (Ptr<Node> node) const
{
  NS_LOG_LOGIC ("Adding GlobalRouter interface to node " << 
		node->GetId ());

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

  NS_LOG_LOGIC ("Adding GlobalRouting Protocol to node " << node->GetId ());
  Ptr<Ipv4GlobalRouting> globalRouting = CreateObject<Ipv4GlobalRouting> ();
  globalRouter->SetRoutingProtocol (globalRouting);

  return globalRouting;
}

void 
Ipv4GlobalRoutingHelper::PopulateRoutingTables (void)
{
  GlobalRouteManager::BuildGlobalRoutingDatabase ();
  GlobalRouteManager::InitializeRoutes ();
}
void 
Ipv4GlobalRoutingHelper::RecomputeRoutingTables (void)
{
  GlobalRouteManager::DeleteGlobalRoutes ();
  GlobalRouteManager::BuildGlobalRoutingDatabase ();
  GlobalRouteManager::InitializeRoutes ();
}


} // namespace ns3




#ifndef IPV4_GLOBAL_ROUTING_HELPER_H
#define IPV4_GLOBAL_ROUTING_HELPER_H

#include "node-container.h"
#include "ipv4-routing-helper.h"

namespace ns3 {

class Ipv4GlobalRoutingHelper  : public Ipv4RoutingHelper
{
public:
  Ipv4GlobalRoutingHelper ();
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;
  static void PopulateRoutingTables (void);
  static void RecomputeRoutingTables (void);
};

} // namespace ns3

#endif /* IPV4_GLOBAL_ROUTING_HELPER_H */




#include "ipv4-list-routing-helper.h"
#include "ns3/ipv4-list-routing.h"
#include "ns3/node.h"

namespace ns3 {

Ipv4ListRoutingHelper::Ipv4ListRoutingHelper()
{}
void 
Ipv4ListRoutingHelper::Add (const Ipv4RoutingHelper &routing, int16_t priority)
{
  m_list.push_back (std::make_pair(&routing,priority));
}
Ptr<Ipv4RoutingProtocol> 
Ipv4ListRoutingHelper::Create (Ptr<Node> node) const
{
  Ptr<Ipv4ListRouting> list = CreateObject<Ipv4ListRouting> ();
  for (std::list<std::pair<const Ipv4RoutingHelper *,int16_t> >::const_iterator i = m_list.begin ();
       i != m_list.end (); ++i)
    {
      Ptr<Ipv4RoutingProtocol> prot = i->first->Create (node);
      list->AddRoutingProtocol (prot,i->second);
    }
  return list;
}

} // namespace ns3




#ifndef IPV4_LIST_ROUTING_HELPER_H
#define IPV4_LIST_ROUTING_HELPER_H

#include "ipv4-routing-helper.h"
#include <stdint.h>
#include <list>

namespace ns3 {

class Ipv4ListRoutingHelper : public Ipv4RoutingHelper
{
public:
  Ipv4ListRoutingHelper();
  void Add (const Ipv4RoutingHelper &routing, int16_t priority);
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;
private:
  std::list<std::pair<const Ipv4RoutingHelper *,int16_t> > m_list;
};

} // namespace ns3

#endif /* IPV4_LIST_ROUTING_HELPER_H */

(-)0053aa3d8c22 (+8 lines)

Added	Link Here

#include "ipv4-routing-helper.h"

namespace ns3 {

Ipv4RoutingHelper::~Ipv4RoutingHelper ()

{}

} // namespace ns3




#ifndef IPV4_ROUTING_HELPER_H
#define IPV4_ROUTING_HELPER_H

#include "ns3/ptr.h"

namespace ns3 {

class Ipv4RoutingProtocol;
class Node;

class Ipv4RoutingHelper
{
public:
  virtual ~Ipv4RoutingHelper ();
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const = 0;
};

} // namespace ns3


#endif /* IPV4_ROUTING_HELPER_H */

(-)a/src/helper/ipv4-static-routing-helper.cc (+9 lines)

Lines 33-38	Link Here

namespace ns3 {

namespace ns3 {

Ipv4StaticRoutingHelper::Ipv4StaticRoutingHelper()

{}

Ptr<Ipv4RoutingProtocol>

Ipv4StaticRoutingHelper::Create (Ptr<Node> node) const

  return CreateObject<Ipv4StaticRouting> ();

Ptr<Ipv4StaticRouting>

Ptr<Ipv4StaticRouting>

Ipv4StaticRoutingHelper::GetStaticRouting (Ptr<Ipv4> ipv4) const

Ipv4StaticRoutingHelper::GetStaticRouting (Ptr<Ipv4> ipv4) const




#include "ns3/ipv4-address.h"
#include "ns3/node.h"
#include "ns3/net-device.h"
#include "ipv4-routing-helper.h"
#include "node-container.h"
#include "net-device-container.h"

namespace ns3 {

class Ipv4StaticRoutingHelper : public Ipv4RoutingHelper
{
public:
  Ipv4StaticRoutingHelper();
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;

  Ptr<Ipv4StaticRouting> GetStaticRouting (Ptr<Ipv4> ipv4) const;

  void AddMulticastRoute (Ptr<Node> n, Ipv4Address source, Ipv4Address group,  




  m_agentFactory.SetTypeId ("ns3::olsr::RoutingProtocol");
}

Ptr<Ipv4RoutingProtocol> 
OlsrHelper::Create (Ptr<Node> node) const
                      std::string n0, const AttributeValue &v0,
                      std::string n1, const AttributeValue &v1,
                      std::string n2, const AttributeValue &v2,
                      std::string n3, const AttributeValue &v3,
                      std::string n4, const AttributeValue &v4,
                      std::string n5, const AttributeValue &v5,
                      std::string n6, const AttributeValue &v6,
                      std::string n7, const AttributeValue &v7)
{
  Ptr<olsr::RoutingProtocol> agent = m_agentFactory.Create<olsr::RoutingProtocol> ();
  node->AggregateObject (agent);
  return agent;
  m_agentFactory.Set (n2, v2);
  m_agentFactory.Set (n3, v3);
  m_agentFactory.Set (n4, v4);
  m_agentFactory.Set (n5, v5);
  m_agentFactory.Set (n6, v6);
  m_agentFactory.Set (n7, v7);
}

void 
OlsrHelper::Set (std::string name, const AttributeValue &value)
{
  m_agentFactory.Set (name, value);
    {
      Ptr<Node> node = *i;
      Install (node);
    }
}
void 
OlsrHelper::Install (Ptr<Node> node)
{
  if (node->GetObject<olsr::RoutingProtocol> () != 0)
    {
      NS_FATAL_ERROR ("OlsrHelper::Install(): Aggregating "
         "an Olsr Agent to a node with an existing Olsr RoutingProtocol");
      return;
    }
  Ptr<olsr::RoutingProtocol> agent = m_agentFactory.Create<olsr::RoutingProtocol> ();
  node->AggregateObject (agent);
  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
  Ptr<Ipv4ListRouting> ipv4Routing = DynamicCast<Ipv4ListRouting> (ipv4->GetRoutingProtocol ());
  NS_ASSERT (ipv4Routing);
  ipv4Routing->AddRoutingProtocol (agent, 10);
  agent->Start ();
}
void 
OlsrHelper::Install (std::string nodeName)
{
  Ptr<Node> node = Names::Find<Node> (nodeName);
  Install (node);
}
void 
OlsrHelper::InstallAll (void)
{
  Install (NodeContainer::GetGlobal ());
}

} // namespace ns3




#define OLSR_HELPER_H

#include "ns3/object-factory.h"
#include "ns3/node-container.h"
#include "ns3/node.h"
#include "node-container.h"
#include "ipv4-routing-helper.h"

namespace ns3 {

/**
 * \brief Helper class that adds OLSR routing to nodes.
 */
class OlsrHelper : public Ipv4RoutingHelper
{
public:
  OlsrHelper ();
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;

  /**
   * \brief Set default OLSR routing agent attributes
   */
  void Set (std::string name, const AttributeValue &value);
                 std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
                 std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
                 std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
                 std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
                 std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
                 std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
                 std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
                 std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());

  /**
   * \brief Enable OLSR routing for a set of nodes
   */
  void Install (NodeContainer container);
  /**
   * \brief Enable OLSR routing for a single node
   */
  void Install (Ptr<Node> node);
  /**
   * \brief Enable OLSR routing for a single node
   */
  void Install (std::string nodeName);
  /**
   * \brief Enable OLSR routing for all nodes
   */
  void InstallAll (void);
private:
  ObjectFactory m_agentFactory;
};

(-)a/src/helper/wscript (+6 lines)

Lines 25-30	Link Here

        'v4ping-helper.cc',

        'v4ping-helper.cc',

        'nqos-wifi-mac-helper.cc',

        'nqos-wifi-mac-helper.cc',

        'qos-wifi-mac-helper.cc',

        'qos-wifi-mac-helper.cc',

        'ipv4-global-routing-helper.cc',

        'ipv4-list-routing-helper.cc',

        'ipv4-routing-helper.cc',

    headers = bld.new_task_gen('ns3header')

    headers = bld.new_task_gen('ns3header')

Lines 52-57	Link Here

        'v4ping-helper.h',

        'v4ping-helper.h',

        'nqos-wifi-mac-helper.h',

        'nqos-wifi-mac-helper.h',

        'qos-wifi-mac-helper.h',

        'qos-wifi-mac-helper.h',

        'ipv4-global-routing-helper.h',

        'ipv4-list-routing-helper.h',

        'ipv4-routing-helper.h',

    env = bld.env_of_name('default')

    env = bld.env_of_name('default')

(-)a/src/internet-stack/ipv4-l3-protocol.cc (-5 / +1 lines)

Lines 187-197	Link Here

187

188

  m_interfaces.clear ();

188

  m_interfaces.clear ();

189

  m_node = 0;

189

  m_node = 0;

190

  if (m_routingProtocol)

190

  m_routingProtocol = 0;

191

192

      m_routingProtocol->Dispose ();

193

      m_routingProtocol = 0;

194

195

  Object::DoDispose ();

191

  Object::DoDispose ();

196

192

197

193

(-)a/src/internet-stack/ipv4-l3-protocol.h (-3 lines)

Lines 157-165	Link Here

157

158

  Ptr<NetDevice> GetNetDevice (uint32_t i);

158

  Ptr<NetDevice> GetNetDevice (uint32_t i);

159

160

  void AddRoutingProtocol (Ptr<Ipv4RoutingProtocol> routingProtocol,

161

                           int16_t priority);

162

163

protected:

160

protected:

164

161

165

  virtual void DoDispose (void);

162

  virtual void DoDispose (void);




  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); i++)
    {
      Ptr<Node> node = *i;
      Ptr<GlobalRouter> router = node->GetObject<GlobalRouter> ();
      if (router == 0)
        {
          continue;
        }
      Ptr<Ipv4GlobalRouting> gr = router->GetRoutingProtocol ();
      uint32_t j = 0;
      uint32_t nRoutes = gr->GetNRoutes ();
      NS_LOG_LOGIC ("Deleting " << gr->GetNRoutes ()<< " routes from node " << node->GetId ());

}

//
// 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
// 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.
//
  void
GlobalRouteManagerImpl::SelectRouterNodes () 
{
  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);

      NS_LOG_LOGIC ("Adding GlobalRouting Protocol to node " << node->GetId ());
      Ptr<Ipv4GlobalRouting> globalRouting = CreateObject<Ipv4GlobalRouting> ();
      // Here, we check whether there is an existing Ipv4RoutingProtocol object
      // to add this protocol to.
      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
      NS_ASSERT_MSG (ipv4, "GlobalRouteManagerImpl::SelectRouterNodes (): GetObject for <Ipv4> interface failed");
      // Now, we add this to an Ipv4ListRouting object.  
      // XXX in the future, we may want to allow this to be added to Ipv4
      // directly
      Ptr<Ipv4ListRouting> ipv4ListRouting = DynamicCast<Ipv4ListRouting> (ipv4->GetRoutingProtocol ());
      NS_ASSERT_MSG (ipv4ListRouting, "GlobalRouteManagerImpl::SelectRouterNodes (): Ipv4ListRouting not found"); 
      // This is the object that will keep the global routes.  We insert it
      // at slightly higher priority than static routing (which is at zero).
      // This means that global routes (e.g. host routes) will be consulted
      // before static routes
      // XXX make the below  priority value an attribute
      ipv4ListRouting->AddRoutingProtocol (globalRouting, 3);  
      // Locally cache the globalRouting pointer; we'll need it later
      // when we add routes
      AddGlobalRoutingProtocol (node->GetId (), globalRouting);
    }
}

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

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

      NS_LOG_LOGIC ("Adding GlobalRouting Protocol to node " << node->GetId ());
      Ptr<Ipv4GlobalRouting> globalRouting = CreateObject<Ipv4GlobalRouting> ();
      // This is the object that will keep the global routes.  We insert it
      // at slightly higher priority than static routing (which is at zero).
      // This means that global routes (e.g. host routes) will be consulted
      // before static routes
      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
      NS_ASSERT_MSG (ipv4, "GlobalRouteManagerImpl::SelectRouterNodes (): "
        "GetObject for <Ipv4> interface failed");
      Ptr<Ipv4ListRouting> ipv4ListRouting = DynamicCast<Ipv4ListRouting> (ipv4->GetRoutingProtocol ());
      NS_ASSERT_MSG (ipv4ListRouting, "GlobalRouteManagerImpl::SelectRouterNodes (): Ipv4ListRouting not found"); 
      // XXX make the below  priority value an attribute
      ipv4ListRouting->AddRoutingProtocol (globalRouting, 3);  
      // Locally cache the globalRouting pointer; we'll need it later
      // when we add routes
      AddGlobalRoutingProtocol (node->GetId (), globalRouting);
    }
}

//
// In order to build the routing database, we need to walk the list of nodes
// in the system and look for those that support the GlobalRouter interface.
// These routers will export a number of Link State Advertisements (LSAs)

// Similarly, the vertex <v> has an m_rootOif (outbound interface index) to
// which the packets should be send for forwarding.
//
          
          Ptr<GlobalRouter> router = node->GetObject<GlobalRouter> ();
          if (router == 0)
            {
              continue;
            }
          Ptr<Ipv4GlobalRouting> gr = router->GetRoutingProtocol ();
          NS_ASSERT (gr);
          if (v->GetOutgoingInterfaceId () >= 0)
            {

// Similarly, the vertex <v> has an m_rootOif (outbound interface index) to
// which the packets should be send for forwarding.
//
              Ptr<GlobalRouter> router = node->GetObject<GlobalRouter> ();
              if (router == 0)
                {
                  continue;
                }
              Ptr<Ipv4GlobalRouting> gr = router->GetRoutingProtocol ();
              NS_ASSERT (gr);
              if (v->GetOutgoingInterfaceId () >= 0)
                {

          Ipv4Mask tempmask = lsa->GetNetworkLSANetworkMask ();
          Ipv4Address tempip = lsa->GetLinkStateId ();
          tempip = tempip.CombineMask (tempmask);
          Ptr<GlobalRouter> router = node->GetObject<GlobalRouter> ();
          if (router == 0)
            {
              continue;
            }
          Ptr<Ipv4GlobalRouting> gr = router->GetRoutingProtocol ();
          NS_ASSERT (gr);
          if (v->GetOutgoingInterfaceId () >= 0)
            {

  v->GetParent ()->AddChild (v);
}

  void 
GlobalRouteManagerImpl::AddGlobalRoutingProtocol (uint32_t nodeId, Ptr<Ipv4GlobalRouting> proto)
{
  NS_LOG_FUNCTION (nodeId);
  m_routingProtocols.push_back
    (std::pair<uint32_t, Ptr<Ipv4GlobalRouting> > (nodeId, proto));
  m_routingProtocols.sort ();
}

  Ptr<Ipv4GlobalRouting>
GlobalRouteManagerImpl::GetGlobalRoutingProtocol (uint32_t nodeId)
{
  for (Ipv4GlobalRoutingList::const_iterator rprotoIter = m_routingProtocols.begin (); rprotoIter != m_routingProtocols.end (); rprotoIter++)
    {
      if ((*rprotoIter).first == nodeId)
        {
          return (*rprotoIter).second;
        }
    }
  return 0;
}


} // namespace ns3

#ifdef RUN_SELF_TESTS




#include "ns3/object.h"
#include "ns3/ptr.h"
#include "ns3/ipv4-address.h"
#include "ns3/node-container.h"
#include "global-router-interface.h"

namespace ns3 {

 *
 */
  virtual void DeleteGlobalRoutes ();
/**
 * @brief Select which nodes in the system are to be router nodes and 
 * aggregate the appropriate interfaces onto those nodes.
 * @internal
 *
 */
  virtual void SelectRouterNodes ();

/**
 * @brief Select which nodes in the system are to be router nodes and 
 * aggregate the appropriate interfaces onto those nodes.
 * @internal
 *
 */
  virtual void SelectRouterNodes (NodeContainer c);

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

  void SPFIntraAddStub (GlobalRoutingLinkRecord *l, SPFVertex* v);
  int32_t FindOutgoingInterfaceId (Ipv4Address a, 
    Ipv4Mask amask = Ipv4Mask("255.255.255.255"));

  // Local cache of the Ipv4GlobalRouting objects, indexed by nodeId
  typedef std::list< std::pair< uint32_t, Ptr<Ipv4GlobalRouting> > > Ipv4GlobalRoutingList;
  void AddGlobalRoutingProtocol (uint32_t nodeId, Ptr<Ipv4GlobalRouting> proto);
  Ptr<Ipv4GlobalRouting> GetGlobalRoutingProtocol (uint32_t nodeId);
  Ipv4GlobalRoutingList m_routingProtocols;
};

} // namespace ns3




#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 ();
  InitializeRoutes ();
}

  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 ()->




#ifndef GLOBAL_ROUTE_MANAGER_H
#define GLOBAL_ROUTE_MANAGER_H

#include "ns3/deprecated.h"

namespace ns3 {


 * the nodes in the simulation.  Makes all nodes in the simulation into
 * routers.
 *
 * All this function does is call the functions
 * BuildGlobalRoutingDatabase () and  InitializeRoutes ().
 * InitializeRoutes ().
 *
 * @see SelectRouterNodes ();
 * @see BuildGlobalRoutingDatabase ();
 * @see InitializeRoutes ();
 */
  static void PopulateRoutingTables () NS_DEPRECATED;

/**
 * @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 the three functions
 * SelectRouterNodes (), BuildGlobalRoutingDatabase (), and
 * InitializeRoutes ().
 *
 * @see SelectRouterNodes (Node Container c);
 * @see BuildGlobalRoutingDatabase ();
 * @see InitializeRoutes ();
 */
  static void PopulateRoutingTables (NodeContainer c);

 /**
  *@brief Remove all routes that were previously installed in a prior call

 * @see BuildGlobalRoutingDatabase ();
 * @see InitializeRoutes ();
 */
 static void RecomputeRoutingTables () NS_DEPRECATED;

public:
/**
 * @brief Allocate a 32-bit router ID from monotonically increasing counter.
 */
  static uint32_t AllocateRouterId ();

/**
 * @brief Delete all static routes on all nodes that have a 

  static void DeleteGlobalRoutes ();

/**
 * @brief Select which nodes in the system are to be router nodes and 
 * aggregate the appropriate interfaces onto those nodes.
 * @internal
 *
 */
  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 Allocate a 32-bit router ID from monotonically increasing counter.
 */
  static uint32_t AllocateRouterId ();

private:

/**
 * @brief Build the routing database by gathering Link State Advertisements
 * from each node exporting a GlobalRouter interface.
 * @internal

 */
  static void InitializeRoutes ();

private:
/**
 * @brief Global Route Manager copy construction is disallowed.  There's no 
 * need for it and a compiler provided shallow copy would be wrong.




#include "ns3/node.h"
#include "ns3/ipv4.h"
#include "ns3/bridge-net-device.h"
#include "ipv4-global-routing.h"
#include "global-router-interface.h"
#include <vector>


  ClearLSAs();
}

void 
GlobalRouter::SetRoutingProtocol (Ptr<Ipv4GlobalRouting> routing)
{
  m_routingProtocol = routing;
}
Ptr<Ipv4GlobalRouting> 
GlobalRouter::GetRoutingProtocol (void)
{
  return m_routingProtocol;
}

void
GlobalRouter::DoDispose ()
{
  NS_LOG_FUNCTION_NOARGS ();
  m_routingProtocol = 0;
  Object::DoDispose ();
}


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

Lines 36-41	Link Here

namespace ns3 {

namespace ns3 {

class GlobalRouter;

class GlobalRouter;

class Ipv4GlobalRouting;

/**

/**

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

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

Lines 572-577	Link Here

572

*/

573

*/

573

  GlobalRouter ();

574

  GlobalRouter ();

574

575

576

577

  void SetRoutingProtocol (Ptr<Ipv4GlobalRouting> routing);

578

  Ptr<Ipv4GlobalRouting> GetRoutingProtocol (void);

579

575

/**

580

/**

576

 * @brief Get the Router ID associated with this Global Router.

581

 * @brief Get the Router ID associated with this Global Router.

577

582

Lines 660-665	Link Here

660

  ListOfLSAs_t m_LSAs;

665

  ListOfLSAs_t m_LSAs;

661

666

662

  Ipv4Address m_routerId;

667

  Ipv4Address m_routerId;

668

  Ptr<Ipv4GlobalRouting> m_routingProtocol;

663

669

664

  // inherited from Object

670

  // inherited from Object

665

  virtual void DoDispose (void);

671

  virtual void DoDispose (void);

(-)a/src/routing/global-routing/ipv4-global-routing.cc (-1 / +1 lines)

Lines 19-25	Link Here

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/net-device.h"

#include "ns3/ipv4-route.h"

#include "ns3/ipv4-route.h"

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

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

#include "ipv4-global-routing.h"

#include "ipv4-global-routing.h"

(-)a/src/routing/global-routing/wscript (+1 lines)

Lines 14-18	Link Here

    headers.source = [

    headers.source = [

        'global-router-interface.h',

        'global-router-interface.h',

        'global-route-manager.h',

        'global-route-manager.h',

        'ipv4-global-routing.h',




  return 0;
}

Ptr<Ipv4StaticRouting>
Ipv4ListRouting::GetStaticRouting (void) const
{
  NS_LOG_FUNCTION (this);
  Ipv4StaticRouting* srp;
  for (Ipv4RoutingProtocolList::const_iterator rprotoIter = m_routingProtocols.begin ();
       rprotoIter != m_routingProtocols.end (); rprotoIter++)
    {
      NS_LOG_LOGIC ("Searching for static routing");
      srp = dynamic_cast<Ipv4StaticRouting*> (PeekPointer((*rprotoIter).second));
      if (srp)
        {
          NS_LOG_LOGIC ("Found static routing");
          return Ptr<Ipv4StaticRouting> (srp);
        }
    }
  NS_LOG_LOGIC ("Static routing not found");
  return 0;

}

bool 
Ipv4ListRouting::Compare (const Ipv4RoutingProtocolEntry& a, const Ipv4RoutingProtocolEntry& b)
{





namespace ns3 {

class Ipv4StaticRouting;

/**
 * \ingroup ipv4Routing 
 *

  virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);
  virtual void SetIpv4 (Ptr<Ipv4> ipv4);

  virtual Ptr<Ipv4StaticRouting> GetStaticRouting (void) const;

protected:
  void DoDispose (void);
private:

(-)a/src/routing/olsr/olsr-routing-protocol.cc (+2 lines)

Lines 213-218	Link Here

213

  m_linkTupleTimerFirstTime = true;

213

  m_linkTupleTimerFirstTime = true;

214

215

  m_ipv4 = ipv4;

215

  m_ipv4 = ipv4;

216

217

  Simulator::ScheduleNow (&RoutingProtocol::Start, this);

216

218

217

219

218

void RoutingProtocol::DoDispose ()

220

void RoutingProtocol::DoDispose ()

(-)a/src/routing/olsr/olsr-routing-protocol.h (-2 / +1 lines)

Lines 68-74	Link Here

  RoutingProtocol ();

  RoutingProtocol ();

  virtual ~RoutingProtocol ();

  virtual ~RoutingProtocol ();

  void Start ();

  void SetMainInterface (uint32_t interface);

  void SetMainInterface (uint32_t interface);

private:

private:

Lines 101-107	Link Here

101

  Ptr<Ipv4> m_ipv4;

100

  Ptr<Ipv4> m_ipv4;

102

101

103

private:

102

private:

104

103

  void Start ();

105

  void Clear ();

104

  void Clear ();

106

  uint32_t GetSize () const { return m_table.size (); }

105

  uint32_t GetSize () const { return m_table.size (); }

107

  std::vector<RoutingTableEntry> GetEntries () const;

106

  std::vector<RoutingTableEntry> GetEntries () const;

Return to bug 600