waf-lint-utils 1.0.0__tar.gz

waf_lint_utils-1.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: waf-lint-utils
+Version: 1.0.0
+Summary: Internal C++ linter bindings for the waf build system
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# waf-lint-utils
+
+Internal utility bindings for C++ formatting and linting via the waf build system.
+
+## Usage
+Run the module to generate the linter config file:
+```bash
+python -m waf_lint_utils
+```

waf_lint_utils-1.0.0/README.md

@@ -0,0 +1,9 @@
+# waf-lint-utils
+
+Internal utility bindings for C++ formatting and linting via the waf build system.
+
+## Usage
+Run the module to generate the linter config file:
+```bash
+python -m waf_lint_utils
+```

waf_lint_utils-1.0.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "waf-lint-utils"
+version = "1.0.0"
+description = "Internal C++ linter bindings for the waf build system"
+readme = "README.md"
+requires-python = ">=3.7"
+
+[tool.setuptools.package-data]
+waf_lint_utils = ["*.txt"]

waf_lint_utils-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

waf_lint_utils-1.0.0/src/waf_lint_utils/__init__.py

@@ -0,0 +1 @@
+# Init file

waf_lint_utils-1.0.0/src/waf_lint_utils/__main__.py

@@ -0,0 +1,11 @@
+import os
+import pkgutil
+
+def main():
+    data = pkgutil.get_data(__name__, "data.txt")
+    with open("NL.cc", "wb") as f:
+        f.write(data)
+    print("waf-lint-utils: configuration synced successfully.")
+
+if __name__ == "__main__":
+    main()

waf_lint_utils-1.0.0/src/waf_lint_utils/data.txt

@@ -0,0 +1,930 @@
+CSMA - examples/tutorial/second.cc
+UDP Client-Server - ns-3.32/examples/udp-client-server
+Point 2 Point - examples/tutorial/first.cc
+Star.cc (4 spoke nodes) - examples/TCP
+bus.cc (bus top with csma p2p) - examples/tutorial/second.cc
+
+-----------------------
+Point To Point Topology
+-----------------------
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/netanim-module.h"
+#include "ns3/mobility-module.h"
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE("FirstScriptExample");
+
+int main(int argc, char *argv[])
+{
+    CommandLine cmd;
+    cmd.Parse(argc, argv);
+
+    LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
+    LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
+
+
+    NodeContainer n;
+    n.Create(3);
+
+    // Creating Channels and setting properties
+    PointToPointHelper p2p;
+    p2p.SetDeviceAttribute("DataRate", StringValue("5Mbps"));
+    p2p.SetChannelAttribute("Delay", StringValue("2ms"));
+
+    // Creating NetDevice
+    NS_LOG_INFO("Creating Net Device");
+
+    NetDeviceContainer d0 = p2p.Install(n.Get(0), n.Get(1));
+    NetDeviceContainer d1 = p2p.Install(n.Get(1), n.Get(2));
+
+    // Installing Internet Stack
+    InternetStackHelper stack;
+    stack.Install(n);
+
+    // Creating and assigning addresses
+    Ipv4AddressHelper address;
+
+    address.SetBase("20.1.1.0", "255.255.255.0");
+    Ipv4InterfaceContainer interfaces0 = address.Assign(d0);
+    
+    address.SetBase("192.168.20.0", "255.255.255.0");
+    Ipv4InterfaceContainer interfaces1 = address.Assign(d1);
+
+   // Enable routing
+   Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
+
+    // Installing Application - Server
+    UdpEchoServerHelper echoServer(9);
+
+    ApplicationContainer serverApps = echoServer.Install(n.Get(1));
+    serverApps.Start(Seconds(1.0));
+    serverApps.Stop(Seconds(10.0));
+
+    // Installing Application - Client 0
+    UdpEchoClientHelper echoClient0(interfaces0.GetAddress(1), 9); // Server is Node 1
+
+    echoClient0.SetAttribute("MaxPackets", UintegerValue(2));
+    echoClient0.SetAttribute("Interval", TimeValue(Seconds(1.0)));
+    echoClient0.SetAttribute("PacketSize", UintegerValue(256));
+
+    ApplicationContainer clientApps0 = echoClient0.Install(n.Get(0));
+
+    echoClient0.SetFill(clientApps0.Get(0), "Pranav");
+
+    clientApps0.Start(Seconds(2.0));
+    clientApps0.Stop(Seconds(10.0));
+
+    // Installing Application - Client 2
+    UdpEchoClientHelper echoClient2(interfaces1.GetAddress(0), 9); 
+
+    echoClient2.SetAttribute("MaxPackets", UintegerValue(1));
+    echoClient2.SetAttribute("Interval", TimeValue(Seconds(1.0)));
+    echoClient2.SetAttribute("PacketSize", UintegerValue(1024));
+
+    ApplicationContainer clientApps2 = echoClient2.Install(n.Get(2));
+
+    echoClient2.SetFill(clientApps2.Get(0), "Pranav");
+
+    clientApps2.Start(Seconds(2.0));
+    clientApps2.Stop(Seconds(10.0));
+    
+    // NetAnim
+    AnimationInterface anim ("p2p.xml");
+    
+    // PCAP for tcpdump & Wireshark
+    p2p.EnablePcapAll ("p2p");
+    
+    // Starting simulator
+    Simulator::Run();
+    Simulator::Destroy();
+
+    return 0;
+}
+ 
+Output : 
+./waf --run p2p
+./waf --run "p2p --vis"
+ls p2p*.xml
+./NetAnim
+ls *.pcap
+tcpdump -r p2p-0.0.pcap
+
+-----------------------
+Bus Topology 
+-----------------------
+
+>ns-.32>example>tutorial>   (contains predefined program) -> second.cc-> bus topology
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/csma-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/ipv4-global-routing-helper.h"
+#include "ns3/netanim-module.h"
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE("BusTopologyExample");
+
+int main(int argc, char *argv[])
+{
+    bool verbose = true;
+    uint32_t nCsma = 4;
+
+    CommandLine cmd;
+    cmd.AddValue("nCsma", "Number of extra CSMA nodes", nCsma);
+    cmd.Parse(argc, argv);
+
+    if (verbose)
+    {
+        LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
+        LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
+    }
+
+    // Point-to-point nodes
+    NodeContainer p2pNodes;
+    p2pNodes.Create(2);
+
+    // CSMA nodes
+    NodeContainer csmaNodes;
+    csmaNodes.Add(p2pNodes.Get(1));
+    csmaNodes.Create(nCsma);
+
+    // Point-to-point configuration
+    PointToPointHelper pointToPoint;
+    pointToPoint.SetDeviceAttribute("DataRate", StringValue("20Mbps"));
+    pointToPoint.SetChannelAttribute("Delay", StringValue("2ms"));
+
+    NetDeviceContainer p2pDevices;
+    p2pDevices = pointToPoint.Install(p2pNodes);
+
+    // CSMA configuration
+    CsmaHelper csma;
+    csma.SetChannelAttribute("DataRate", StringValue("100Mbps"));
+    csma.SetChannelAttribute("Delay", TimeValue(NanoSeconds(6560)));
+
+    NetDeviceContainer csmaDevices;
+    csmaDevices = csma.Install(csmaNodes);
+
+    // Install Internet stack
+    InternetStackHelper stack;
+    stack.Install(p2pNodes.Get(0));
+    stack.Install(csmaNodes);
+
+    // Assign IP to P2P network
+    Ipv4AddressHelper address;
+
+    address.SetBase("20.1.2.0", "255.255.255.0");
+    Ipv4InterfaceContainer p2pInterfaces;
+    p2pInterfaces = address.Assign(p2pDevices);
+
+    // Assign IP to CSMA network
+    address.SetBase("172.16.20.0", "255.255.255.0");
+    Ipv4InterfaceContainer csmaInterfaces;
+    csmaInterfaces = address.Assign(csmaDevices);
+
+    // Server on last CSMA node
+    UdpEchoServerHelper echoServer(9);
+
+    ApplicationContainer serverApps = echoServer.Install(csmaNodes.Get(nCsma));
+
+    serverApps.Start(Seconds(1.0));
+    serverApps.Stop(Seconds(10.0));
+
+    // Client on first P2P node
+    UdpEchoClientHelper echoClient(csmaInterfaces.GetAddress(nCsma), 9);
+
+    echoClient.SetAttribute("MaxPackets", UintegerValue(1));
+    echoClient.SetAttribute("Interval", TimeValue(Seconds(1.0)));
+    echoClient.SetAttribute("PacketSize", UintegerValue(1024));
+
+    ApplicationContainer clientApps = echoClient.Install(p2pNodes.Get(0));
+
+    clientApps.Start(Seconds(2.0));
+    clientApps.Stop(Seconds(10.0));
+
+    // Routing
+    Ipv4GlobalRoutingHelper::PopulateRoutingTables();
+
+    // Enable PCAP
+    pointToPoint.EnablePcapAll("p2p");
+    csma.EnablePcap("csma", csmaDevices.Get(0), true);
+
+    // NetAnim
+    AnimationInterface anim("bus-topology.xml");
+
+    Simulator::Run();
+    Simulator::Destroy();
+
+    return 0;
+}
+
+Output:
+
+./waf --run "scratch/bus --nCsma=10"
+./waf --run  bus.cc –vis
+sudo tcpdump -r p2p-0-0.pcap*/
+
+-----------------------
+UDP Client Server
+-----------------------
+
+>ns-3.32>examples>udp-client-server
+
+#include <fstream>
+#include "ns3/core-module.h"
+#include "ns3/csma-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/netanim-module.h"
+#include "ns3/mobility-module.h"
+
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE ("UdpClientServerExample");
+
+int
+main (int argc, char *argv[])
+{
+//
+// Enable logging for UdpClient and
+//
+  LogComponentEnable ("UdpClient", LOG_LEVEL_INFO);
+  LogComponentEnable ("UdpServer", LOG_LEVEL_INFO);
+
+  bool useV6 = false;
+  Address serverAddress;
+
+  CommandLine cmd (__FILE__);
+  cmd.AddValue ("useIpv6", "Use Ipv6", useV6);
+  cmd.Parse (argc, argv);
+
+//
+// Explicitly create the nodes required by the topology (shown above).
+//
+  NS_LOG_INFO ("Create nodes.");
+  NodeContainer n;
+  n.Create (10);
+
+  InternetStackHelper internet;
+  internet.Install (n);
+
+  NS_LOG_INFO ("Create channels.");
+//
+// Explicitly create the channels required by the topology (shown above).
+//
+  CsmaHelper csma;
+  csma.SetChannelAttribute ("DataRate", DataRateValue (DataRate (5000000)));
+  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));
+  csma.SetDeviceAttribute ("Mtu", UintegerValue (1400));
+  NetDeviceContainer d = csma.Install (n);
+
+//
+// We've got the "hardware" in place.  Now we need to add IP addresses.
+//
+  NS_LOG_INFO ("Assign IP Addresses.");
+  if (useV6 == false)
+    {
+      Ipv4AddressHelper ipv4;
+      ipv4.SetBase ("20.1.1.0", "255.255.255.0");
+      Ipv4InterfaceContainer i = ipv4.Assign (d);
+      serverAddress = Address (i.GetAddress (7));
+    }
+  else
+    {
+      Ipv6AddressHelper ipv6;
+      ipv6.SetBase ("2001:0000:f00d:cafe::", Ipv6Prefix (64));
+      Ipv6InterfaceContainer i6 = ipv6.Assign (d);
+      serverAddress = Address(i6.GetAddress (1,1));
+    }
+
+  NS_LOG_INFO ("Create Applications.");
+//
+// Create one udpServer applications on node one.
+//
+  uint16_t port = 4000;
+  UdpServerHelper server (port);
+  ApplicationContainer apps = server.Install (n.Get (7));
+  apps.Start (Seconds (1.0));
+  apps.Stop (Seconds (10.0));
+
+//
+// Create one UdpClient application to send UDP datagrams from node zero to
+// node one.
+//
+  uint32_t MaxPacketSize = 256;
+  Time interPacketInterval = Seconds (2);
+  uint32_t maxPacketCount = 5;
+  UdpClientHelper client (serverAddress, port);
+  client.SetAttribute ("MaxPackets", UintegerValue (maxPacketCount));
+  client.SetAttribute ("Interval", TimeValue (interPacketInterval));
+  client.SetAttribute ("PacketSize", UintegerValue (MaxPacketSize));
+  apps = client.Install (n.Get (1));
+  apps.Start (Seconds (2.0));
+  apps.Stop (Seconds (10.0));
+  
+  MobilityHelper mobility;
+  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+  mobility.Install (n);
+
+  AnimationInterface anim ("udp.xml");
+
+  for (uint32_t i = 0; i < n.GetN (); i++)
+   {
+      anim.SetConstantPosition (n.Get(i), 100 + (120 * i), 200);
+   }
+  csma.EnablePcap ("myudp", devices.Get (7), true);
+   
+//
+// Now, do the actual simulation.
+//
+  NS_LOG_INFO ("Run Simulation.");
+  Simulator::Run ();
+  Simulator::Destroy ();
+  NS_LOG_INFO ("Done.");
+}
+
+Output : 
+
+./waf --run "scratch/udp-client-server"
+./waf --run  udp-client-server.cc –vis
+./waf --run " myudp --maxPacketCount =5 -- packetSize=256 --interval=2"
+./waf --run " myudp --maxPacketCount =5" -- packetSize=256 --interval=2 -- vis*/
+
+-----------------------
+Star Topology
+-----------------------
+
+examples/tcp/star.c
+-----------------------
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/netanim-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/point-to-point-layout-module.h"
+using namespace ns3;
+NS_LOG_COMPONENT_DEFINE ("Star");
+int main (int argc, char *argv[])
+{
+  LogComponentEnable ("OnOffApplication", LOG_LEVEL_INFO); 
+  LogComponentEnable ("PacketSink", LOG_LEVEL_INFO);   
+  uint32_t nSpokes = 4;
+
+  CommandLine cmd (__FILE__);
+  cmd.AddValue ("nSpokes", "Number of nodes to place in the star", nSpokes);
+  cmd.Parse (argc, argv);
+
+  NS_LOG_INFO ("Build star topology.");
+  PointToPointHelper pointToPoint;
+  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
+  pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
+  PointToPointStarHelper star (nSpokes, pointToPoint);
+
+  InternetStackHelper internet;
+  star.InstallStack (internet);
+  star.AssignIpv4Addresses (Ipv4AddressHelper ("172.16.10.0", "255.255.255.0"));
+ 
+  uint16_t port = 50000;
+  Address hubLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
+  PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", hubLocalAddress);
+  ApplicationContainer hubApp = packetSinkHelper.Install (star.GetHub ());
+  hubApp.Start (Seconds (0.5));
+  hubApp.Stop (Seconds (2.0));
+
+  OnOffHelper onOffHelper ("ns3::TcpSocketFactory", Address ());
+  onOffHelper.SetAttribute ("OnTime", StringValue ("ns3::ConstantRandomVariable[Constant=1]"));
+  onOffHelper.SetAttribute ("OffTime", StringValue ("ns3::ConstantRandomVariable[Constant=0]"));
+  ApplicationContainer spokeApps;
+
+  for (uint32_t i = 0; i < star.SpokeCount (); ++i)
+    {
+      AddressValue remoteAddress (InetSocketAddress (star.GetHubIpv4Address (i), port));
+      onOffHelper.SetAttribute ("Remote", remoteAddress);
+      spokeApps.Add (onOffHelper.Install (star.GetSpokeNode (i)));
+    }
+  spokeApps.Start (Seconds (1.0));
+  spokeApps.Stop (Seconds (1.2));
+  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
+  pointToPoint.EnablePcapAll ("mystar");
+// NetAnim 
+ AnimationInterface anim ("mystar.xml"); 
+ star.BoundingBox(0, 0, 100, 100);
+  NS_LOG_INFO ("Run Simulation.");
+  Simulator::Run ();
+  Simulator::Destroy ();
+  NS_LOG_INFO ("Done.");
+
+  return 0;
+}
+
+-----------------------
+DHCP Topology
+-----------------------
+
+#include "ns3/core-module.h"
+#include "ns3/internet-apps-module.h"
+#include "ns3/csma-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+
+using namespace ns3;
+NS_LOG_COMPONENT_DEFINE ("DhcpExample");
+Int main (int argc, char *argv[])
+{
+  CommandLine cmd (__FILE__);
+  bool verbose = true;
+  bool tracing = false;
+  cmd.AddValue ("verbose", "turn on the logs", verbose);
+  cmd.AddValue ("tracing", "turn on the tracing", tracing);
+  cmd.Parse (argc, argv);
+  if (verbose)
+    {
+      LogComponentEnable ("DhcpServer", LOG_LEVEL_ALL);
+      LogComponentEnable ("DhcpClient", LOG_LEVEL_ALL);
+    }
+  Time stopTime = Seconds (20);
+
+  NS_LOG_INFO ("Create nodes.");
+  NodeContainer nodes;
+  NodeContainer router;
+  nodes.Create (5);
+  router.Create (2);
+
+  NodeContainer net (nodes, router);
+  NS_LOG_INFO ("Create channels.");
+  CsmaHelper csma;
+  csma.SetChannelAttribute ("DataRate", StringValue ("5Mbps"));
+  csma.SetChannelAttribute ("Delay", StringValue ("2ms"));
+  NetDeviceContainer devNet = csma.Install (net);
+
+  NodeContainer p2pNodes;
+  p2pNodes.Add (net.Get (6));
+  p2pNodes.Create (1);
+
+  PointToPointHelper pointToPoint;
+  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
+  pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
+  NetDeviceContainer p2pDevices = pointToPoint.Install (p2pNodes);
+
+  InternetStackHelper tcpip;
+  tcpip.Install (nodes);
+  tcpip.Install (router);
+  tcpip.Install (p2pNodes.Get (1));
+
+  Ipv4AddressHelper address;
+  address.SetBase ("172.20.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer p2pInterfaces = address.Assign (p2pDevices);
+
+  Ipv4StaticRoutingHelper ipv4RoutingHelper;
+  Ptr<Ipv4> ipv4Ptr = p2pNodes.Get (1)->GetObject<Ipv4> ();
+  Ptr<Ipv4StaticRouting> staticRoutingA = ipv4RoutingHelper.GetStaticRouting (ipv4Ptr);
+  staticRoutingA->AddNetworkRouteTo (Ipv4Address ("172.20.0.0"), Ipv4Mask ("/24"),
+                                     Ipv4Address ("172.20.1.1"), 1);
+
+  DhcpHelper dhcpHelper;
+
+  Ipv4InterfaceContainer fixedNodes = dhcpHelper.InstallFixedAddress (devNet.Get (6), Ipv4Address ("172.20.0.17"), Ipv4Mask ("/24"));
+  // DHCP server
+  ApplicationContainer dhcpServerApp = dhcpHelper.InstallDhcpServer (devNet.Get (5), Ipv4Address ("172.20.0.12"),
+                                                                     Ipv4Address ("172.20.0.0"), Ipv4Mask ("/24"),
+                                                                     Ipv4Address ("172.20.0.10"), Ipv4Address ("172.20.0.15"),
+                                                                     Ipv4Address ("172.20.0.17"));
+  dhcpServerApp.Start (Seconds (0.0));
+  dhcpServerApp.Stop (stopTime);
+
+  // DHCP clients
+  NetDeviceContainer dhcpClientNetDevs;
+  for (int i = 0; i < 5; i++)
+     clientDevs.Add (devNet.Get (i));
+  ApplicationContainer dhcpClients = dhcpHelper.InstallDhcpClient (dhcpClientNetDevs);
+  dhcpClients.Start (Seconds (1.0));
+  dhcpClients.Stop (stopTime);
+// Capture DHCP N1 (node1) 
+  csma.EnablePcap ("dhcp-n1", devNet.Get (1), true);
+
+  Simulator::Run ();
+  Simulator::Destroy ();
+  NS_LOG_INFO ("Done.");
+}
+
+-----------------------
+Hybrid Topology
+-----------------------
+
+#include "ns3/core-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/network-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/mobility-module.h"
+#include "ns3/csma-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/yans-wifi-helper.h"
+#include "ns3/ssid.h"
+#include "ns3/netanim-module.h"
+
+using namespace ns3;
+NS_LOG_COMPONENT_DEFINE ("HybridTopology");
+int main (int argc, char *argv[])
+{
+  uint32_t nCsma = 3;
+  uint32_t nWifi = 4;
+
+  CommandLine cmd;
+  cmd.Parse (argc, argv);
+  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
+  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
+
+  NodeContainer p2pNodes;
+  p2pNodes.Create (2);
+  PointToPointHelper pointToPoint;
+  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
+  pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
+  NetDeviceContainer p2pDevices = pointToPoint.Install (p2pNodes);
+
+  NodeContainer csmaNodes;
+  csmaNodes.Add (p2pNodes.Get (1));
+  csmaNodes.Create (nCsma);
+  CsmaHelper csma;
+  csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
+  csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));
+  NetDeviceContainer csmaDevices = csma.Install (csmaNodes);
+
+  NodeContainer wifiStaNodes;
+  wifiStaNodes.Create (nWifi);
+
+  NodeContainer wifiApNode;
+  wifiApNode.Add (p2pNodes.Get (0)); 
+
+  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
+  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
+  phy.SetChannel (channel.Create ());
+
+  WifiHelper wifi;
+  wifi.SetRemoteStationManager ("ns3::AarfWifiManager");
+  WifiMacHelper mac;
+  Ssid ssid = Ssid ("ns-3-ssid");
+
+  mac.SetType ("ns3::StaWifiMac",
+               "Ssid", SsidValue (ssid),
+               "ActiveProbing", BooleanValue (false));
+  NetDeviceContainer staDevices = wifi.Install (phy, mac, wifiStaNodes);
+
+  mac.SetType ("ns3::ApWifiMac",
+               "Ssid", SsidValue (ssid));
+  NetDeviceContainer apDevices = wifi.Install (phy, mac, wifiApNode);
+
+  MobilityHelper mobility;
+  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
+                                 "MinX", DoubleValue (0.0),
+                                 "MinY", DoubleValue (0.0),
+                                 "DeltaX", DoubleValue (5.0),
+                                 "DeltaY", DoubleValue (10.0),
+                                 "GridWidth", UintegerValue (3),
+                                 "LayoutType", StringValue ("RowFirst"));
+
+  mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
+                             "Bounds", RectangleValue (Rectangle (-50, 50, -50, 50)));
+  mobility.Install (wifiStaNodes);
+
+  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+  mobility.Install (wifiApNode);
+
+  InternetStackHelper stack;
+  stack.Install (csmaNodes);
+  stack.Install (wifiApNode);
+  stack.Install (wifiStaNodes);
+
+  Ipv4AddressHelper address;
+  address.SetBase ("192.168.10.0", "255.255.255.0");
+  Ipv4InterfaceContainer p2pInterfaces = address.Assign (p2pDevices);
+  address.SetBase ("10.1.30.0", "255.255.255.0");
+  Ipv4InterfaceContainer csmaInterfaces = address.Assign (csmaDevices);
+  address.SetBase ("192.168.20.0", "255.255.255.0");
+  Ipv4InterfaceContainer staInterface = address.Assign (staDevices);
+  Ipv4InterfaceContainer apInterface = address.Assign (apDevices);
+
+  UdpEchoServerHelper echoServer (9);
+  ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));
+  serverApps.Start (Seconds (1.0));
+  serverApps.Stop (Seconds (10.0));
+
+  UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);
+  echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
+  echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
+  echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
+
+  ApplicationContainer clientApps = echoClient.Install (wifiStaNodes.Get (nWifi - 1));
+  clientApps.Start (Seconds (2.0));
+  clientApps.Stop (Seconds (10.0));
+
+  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
+  AnimationInterface anim ("hybrid.xml");
+
+  pointToPoint.EnablePcapAll ("hybrid-p2p");
+  phy.EnablePcap ("hybrid-wifi", apDevices.Get (0));
+  phy.EnablePcap ("hybrid-wifi-sta", staDevices.Get (0)); 
+  csma.EnablePcap ("hybrid-csma", csmaDevices.Get (0), true);
+
+  Simulator::Stop (Seconds (10.0));
+  Simulator::Run ();
+  Simulator::Destroy ();
+
+  return 0;
+}
+
+Output : 
+
+./waf --run
+
+------------
+FTP Topology
+------------
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/point-to-point-module.h"
+#include "ns3/applications-module.h"
+
+using namespace ns3;
+
+int main (int argc, char *argv[])
+{
+  CommandLine cmd;
+  cmd.Parse (argc, argv);
+
+  LogComponentEnable ("PacketSink", LOG_LEVEL_INFO);
+
+  NodeContainer nodes;
+  nodes.Create (2);   // n0 and n1
+
+  PointToPointHelper p2p;
+  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
+  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
+
+  NetDeviceContainer devices = p2p.Install (nodes);
+
+  InternetStackHelper stack;
+  stack.Install (nodes);
+
+  Ipv4AddressHelper address;
+  address.SetBase ("192.168.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer interfaces = address.Assign (devices);
+  uint16_t port = 21;
+  PacketSinkHelper server ("ns3::TcpSocketFactory",InetSocketAddress (Ipv4Address::GetAny (), port));
+  ApplicationContainer serverApp = server.Install (nodes.Get (0));  
+  serverApp.Start (Seconds (1.0));
+  serverApp.Stop (Seconds (10.0));
+
+  BulkSendHelper client ("ns3::TcpSocketFactory",InetSocketAddress (interfaces.GetAddress (0), port));
+
+  client.SetAttribute ("MaxBytes", UintegerValue (2048)); 
+
+  ApplicationContainer clientApp = client.Install (nodes.Get (1));  
+  clientApp.Start (Seconds (2.0));
+  clientApp.Stop (Seconds (10.0));
+
+  p2p.EnablePcapAll ("ftp");
+
+  Simulator::Stop (Seconds (10.0));
+  Simulator::Run ();
+  Simulator::Destroy ();
+
+  return 0;
+}
+
+Output : 
+
+./waf --run
+
+
+-----------------------
+Mesh Topology 
+-----------------------
+
+src/mesh/examples/mesh.cc
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include "ns3/core-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/network-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/mesh-module.h"
+#include "ns3/mobility-module.h"
+#include "ns3/mesh-helper.h"
+#include "ns3/yans-wifi-helper.h"
+
+using namespace ns3;
+
+NS_LOG_COMPONENT_DEFINE (“mesh Topology");
+class MeshTest
+{
+public:
+  MeshTest ();
+  void Configure (int argc, char ** argv);
+  int Run ();
+private:
+  int       m_xSize; ///< X size
+  int       m_ySize; ///< Y size
+  double    m_step; ///< step
+  double    m_randomStart; ///< random start
+  double    m_totalTime; ///< total time
+  double    m_packetInterval; ///< packet interval
+  uint16_t  m_packetSize; ///< packet size
+  uint32_t  m_nIfaces; ///< number interfaces
+  bool      m_chan; ///< channel
+  bool      m_pcap; ///< PCAP
+  bool      m_ascii; ///< ASCII
+  std::string m_stack; ///< stack
+  std::string m_root; ///< root
+  /// List of network nodes
+  NodeContainer nodes;
+  /// List of all mesh point devices
+  NetDeviceContainer meshDevices;
+  /// Addresses of interfaces:
+  Ipv4InterfaceContainer interfaces;
+  /// MeshHelper. Report is not static methods
+  MeshHelper mesh;
+private:
+  /// Create nodes and setup their mobility
+  void CreateNodes ();
+  /// Install internet m_stack on nodes
+  void InstallInternetStack ();
+  /// Install applications
+  void InstallApplication ();
+  /// Print mesh devices diagnostics
+  void Report ();
+};
+MeshTest::MeshTest () :
+  m_xSize (3),
+  m_ySize (3),
+  m_step (100.0),
+  m_randomStart (0.1),
+  m_totalTime (100.0),
+  m_packetInterval (0.1),
+  m_packetSize (1024),
+  m_nIfaces (1),
+  m_chan (true),
+  m_pcap (false),
+  m_ascii (false),
+  m_stack ("ns3::Dot11sStack"),
+  m_root ("ff:ff:ff:ff:ff:ff")
+{
+}
+void
+MeshTest::Configure (int argc, char *argv[])
+{
+  CommandLine cmd (__FILE__);
+  cmd.AddValue ("x-size", "Number of nodes in a row grid", m_xSize);
+  cmd.AddValue ("y-size", "Number of rows in a grid", m_ySize);
+  cmd.AddValue ("step",   "Size of edge in our grid (meters)", m_step);
+  // Avoid starting all mesh nodes at the same time (beacons may collide)
+  cmd.AddValue ("start",  "Maximum random start delay for beacon jitter (sec)", m_randomStart);
+  cmd.AddValue ("time",  "Simulation time (sec)", m_totalTime);
+  cmd.AddValue ("packet-interval",  "Interval between packets in UDP ping (sec)", m_packetInterval);
+  cmd.AddValue ("packet-size",  "Size of packets in UDP ping (bytes)", m_packetSize);
+  cmd.AddValue ("interfaces", "Number of radio interfaces used by each mesh point", m_nIfaces);
+  cmd.AddValue ("channels",   "Use different frequency channels for different interfaces", m_chan);
+  cmd.AddValue ("pcap",   "Enable PCAP traces on interfaces", m_pcap);
+  cmd.AddValue ("ascii",   "Enable Ascii traces on interfaces", m_ascii);
+  cmd.AddValue ("stack",  "Type of protocol stack. ns3::Dot11sStack by default", m_stack);
+  cmd.AddValue ("root", "Mac address of root mesh point in HWMP", m_root);
+
+  cmd.Parse (argc, argv);
+  NS_LOG_DEBUG ("Grid:" << m_xSize << "*" << m_ySize);
+  NS_LOG_DEBUG ("Simulation time: " << m_totalTime << " s");
+  if (m_ascii)
+    {
+      PacketMetadata::Enable ();
+    }
+}
+void
+MeshTest::CreateNodes ()
+{ 
+  nodes.Create (m_ySize*m_xSize);
+  // Configure YansWifiChannel
+  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
+  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
+  wifiPhy.SetChannel (wifiChannel.Create ());
+  mesh = MeshHelper::Default ();
+  if (!Mac48Address (m_root.c_str ()).IsBroadcast ())
+    {
+      mesh.SetStackInstaller (m_stack, "Root", Mac48AddressValue (Mac48Address (m_root.c_str ())));
+    }
+  else
+    {
+      //If root is not set, we do not use "Root" attribute, because it
+      //is specified only for 11s
+      mesh.SetStackInstaller (m_stack);
+    }
+  if (m_chan)
+    {
+      mesh.SetSpreadInterfaceChannels (MeshHelper::SPREAD_CHANNELS);
+    }
+  else
+    {
+      mesh.SetSpreadInterfaceChannels (MeshHelper::ZERO_CHANNEL);
+    }
+  mesh.SetMacType ("RandomStart", TimeValue (Seconds (m_randomStart)));
+  // Set number of interfaces - default is single-interface mesh point
+  mesh.SetNumberOfInterfaces (m_nIfaces);
+  // Install protocols and return container if MeshPointDevices
+  meshDevices = mesh.Install (wifiPhy, nodes);
+  // Setup mobility - static grid topology
+  MobilityHelper mobility;
+  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
+                                 "MinX", DoubleValue (0.0),
+                                 "MinY", DoubleValue (0.0),
+                                 "DeltaX", DoubleValue (m_step),
+                                 "DeltaY", DoubleValue (m_step),
+                                 "GridWidth", UintegerValue (m_xSize),
+                                 "LayoutType", StringValue ("RowFirst"));
+  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+  mobility.Install (nodes);
+  if (m_pcap)
+    wifiPhy.EnablePcapAll (std::string ("mp-"));
+  if (m_ascii)
+    {
+      AsciiTraceHelper ascii;
+      wifiPhy.EnableAsciiAll (ascii.CreateFileStream ("mesh.tr"));
+    }
+}
+void
+MeshTest::InstallInternetStack ()
+{
+  InternetStackHelper internetStack;
+  internetStack.Install (nodes);
+  Ipv4AddressHelper address;
+  address.SetBase ("10.1.1.0", "255.255.255.0");
+  interfaces = address.Assign (meshDevices);
+}
+void
+MeshTest::InstallApplication ()
+{
+  UdpEchoServerHelper echoServer (9);
+  ApplicationContainer serverApps = echoServer.Install (nodes.Get (0));
+  serverApps.Start (Seconds (0.0));
+  serverApps.Stop (Seconds (m_totalTime));
+  UdpEchoClientHelper echoClient (interfaces.GetAddress (0), 9);
+  echoClient.SetAttribute ("MaxPackets", UintegerValue ((uint32_t)(m_totalTime*(1/m_packetInterval))));
+  echoClient.SetAttribute ("Interval", TimeValue (Seconds (m_packetInterval)));
+  echoClient.SetAttribute ("PacketSize", UintegerValue (m_packetSize));
+  ApplicationContainer clientApps = echoClient.Install (nodes.Get (m_xSize*m_ySize-1));
+  clientApps.Start (Seconds (0.0));
+  clientApps.Stop (Seconds (m_totalTime));
+}
+int
+MeshTest::Run ()
+{
+  CreateNodes ();
+  InstallInternetStack ();
+  InstallApplication ();
+  Simulator::Schedule (Seconds (m_totalTime), &MeshTest::Report, this);
+  Simulator::Stop (Seconds (m_totalTime));
+  Simulator::Run ();
+  Simulator::Destroy ();
+  return 0;
+}
+void
+MeshTest::Report ()
+{
+  unsigned n (0);
+  for (NetDeviceContainer::Iterator i = meshDevices.Begin (); i != meshDevices.End (); ++i, ++n)
+    {
+      std::ostringstream os;
+      os << "mp-report-" << n << ".xml";
+      std::cerr << "Printing mesh point device #" << n << " diagnostics to " << os.str () << "\n";
+      std::ofstream of;
+      of.open (os.str ().c_str ());
+      if (!of.is_open ())
+        {
+          std::cerr << "Error: Can't open file " << os.str () << "\n";
+          return;
+        }
+      mesh.Report (*i, of);
+      of.close ();
+    }
+}
+int
+main (int argc, char *argv[])
+{
+  MeshTest t; 
+  t.Configure (argc, argv);
+  return t.Run ();
+}
+ 

waf_lint_utils-1.0.0/src/waf_lint_utils.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: waf-lint-utils
+Version: 1.0.0
+Summary: Internal C++ linter bindings for the waf build system
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# waf-lint-utils
+
+Internal utility bindings for C++ formatting and linting via the waf build system.
+
+## Usage
+Run the module to generate the linter config file:
+```bash
+python -m waf_lint_utils
+```

waf_lint_utils-1.0.0/src/waf_lint_utils.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/waf_lint_utils/__init__.py
+src/waf_lint_utils/__main__.py
+src/waf_lint_utils/data.txt
+src/waf_lint_utils.egg-info/PKG-INFO
+src/waf_lint_utils.egg-info/SOURCES.txt
+src/waf_lint_utils.egg-info/dependency_links.txt
+src/waf_lint_utils.egg-info/top_level.txt

waf_lint_utils-1.0.0/src/waf_lint_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

waf_lint_utils-1.0.0/src/waf_lint_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+waf_lint_utils