Exemplo n.º 1
0
    def connect_tap_to_bridge(self, bridge_name=None):
        """Connect a ns-3 tap device to the bridge.

        Parameters
        ----------
        bridge_name : str
            The bridge to connect the tap (and ns-3) device to.
        """
        if bridge_name is None:
            bridge_name = self.bridge_name

        ipr = IPRoute()

        logger.debug('Connect %s to bridge %s via %s', self.node.name, bridge_name, self.tap_name)
        ipr.link('add', ifname=self.tap_name, kind='tuntap', mode='tap')
        defer(f'disconnect ns3 node {self.node.name}', self.disconnect_tap_from_bridge)

        ipr.link('set', ifname=self.tap_name, state='up')

        ipr.link('set', ifname=self.tap_name, master=ipr.link_lookup(ifname=bridge_name)[0])

        logger.debug("Adding TapBridge for %s.", self.node.name)
        tap_helper = tap_bridge.TapBridgeHelper()
        # ConfigureLocal is used to prevent the TAP / bridged device to use a "learned" MAC address.
        # So, we can set the CSMA and WiFiNetDevice address to something we control.
        # Otherwise, WiFi ACK misses happen.
        tap_helper.SetAttribute('Mode', core.StringValue('ConfigureLocal'))
        tap_helper.SetAttribute('DeviceName', core.StringValue(self.tap_name))
        tap_helper.SetAttribute('MacAddress', ns_net.Mac48AddressValue(ns_net.Mac48Address.Allocate()))
        tap_helper.Install(self.node.ns3_node, self.ns3_device)
Exemplo n.º 2
0
 def set_delay(self, delay):
     logger.info(f'Set delay of channel {self.channel_name} to {delay}')
     self.delay = delay
     if self.csma_channel is not None:
         core.Config.Set(
             "/ChannelList/" + str(self.csma_channel.GetId()) +
             "/$ns3::CsmaChannel/Delay", core.StringValue(str(self.delay)))
Exemplo n.º 3
0
    def __init__(self, network, nodes, delay="0ms", speed="100Mbps"):
        super().__init__(network, nodes)

        #: The channel's delay.
        self.delay = delay
        #: The channel's speed for transmitting and receiving.
        #:
        #: Valid values e.g. are :code:`'100Mbps'` or :code:`'64kbps'`.
        self.speed = speed

        #: A helper for connecting nodes via CSMA.
        self.csma_helper = csma.CsmaHelper()

        logger.info('Install connection between nodes')
        self.csma_helper.SetChannelAttribute("DataRate",
                                             core.StringValue(self.speed))
        self.csma_helper.SetChannelAttribute("Delay",
                                             core.StringValue(self.delay))

        #: All ns-3 devices on this channel.
        self.devices_container = self.csma_helper.Install(
            self.ns3_nodes_container)

        logger.info('Set IP addresses on nodes')
        stack_helper = internet.InternetStackHelper()

        for i, node in enumerate(nodes):
            ns3_device = self.devices_container.Get(i)

            address = None
            if node.wants_ip_stack():
                if node.ns3_node.GetObject(internet.Ipv4.GetTypeId()) is None:
                    logger.info('Installing IP stack on %s', node.name)
                    stack_helper.Install(node.ns3_node)
                device_container = ns_net.NetDeviceContainer(ns3_device)
                ip_address = self.network.address_helper.Assign(
                    device_container).GetAddress(0)
                netmask = network.network.prefixlen
                address = ipaddress.ip_interface(f'{ip_address}/{netmask}')

            interface = Interface(node=node,
                                  ns3_device=ns3_device,
                                  address=address)
            ns3_device.SetAddress(ns_net.Mac48Address(interface.mac_address))
            node.add_interface(interface)
            self.interfaces.append(interface)
Exemplo n.º 4
0
 def set_data_rate(self, data_rate):
     logger.info(f'Set speed of channel {self.channel_name} to {data_rate}')
     self.data_rate = data_rate
     if self.csma_channel is not None:
         core.Config.Set(
             "/ChannelList/" +
             str(self.csma_channel.GetId()) + "/$ns3::CsmaChannel/DataRate",
             core.StringValue(self.data_rate))
Exemplo n.º 5
0
    def __init__(self, network, nodes, frequency=None, channel=1, channel_width=40, antennas=1, tx_power=20.0,
                 standard: WiFiStandard = WiFiStandard.WIFI_802_11b,
                 data_rate: WiFiDataRate = WiFiDataRate.DSSS_RATE_11Mbps):
        super().__init__(network, nodes)

        #: The channel to use.
        self.channel = channel
        #: The frequency to use.
        #:
        #: This could collide with other WiFi channels.
        self.frequency = frequency
        #: The width of the channel in MHz.
        self.channel_width = channel_width
        #: The number of antennas to use.
        self.antennas = antennas
        #: The sending power in dBm.
        self.tx_power = tx_power
        #: The WiFi standard to use.
        self.standard = standard
        #: The data rate to use.
        self.data_rate = data_rate

        logger.debug("Setting up physical layer of WiFi.")
        self.wifi_phy_helper = wifi.YansWifiPhyHelper.Default()
        self.wifi_phy_helper.Set("ChannelWidth", core.UintegerValue(self.channel_width))
        if self.frequency:
            self.wifi_phy_helper.Set("Frequency", core.UintegerValue(self.frequency))
        else:
            self.wifi_phy_helper.Set("ChannelNumber", core.UintegerValue(self.channel))
        self.wifi_phy_helper.Set("Antennas", core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedTxSpatialStreams", core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedRxSpatialStreams", core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("TxPowerStart", core.DoubleValue(self.tx_power))
        self.wifi_phy_helper.Set("TxPowerEnd", core.DoubleValue(self.tx_power))

        # Enable monitoring of radio headers.
        self.wifi_phy_helper.SetPcapDataLinkType(wifi.WifiPhyHelper.DLT_IEEE802_11_RADIO)

        wifi_channel = wifi.YansWifiChannel()
        self.propagation_delay_model = propagation.ConstantSpeedPropagationDelayModel()
        wifi_channel.SetAttribute("PropagationDelayModel", core.PointerValue(self.propagation_delay_model))

        if self.standard == WiFiChannel.WiFiStandard.WIFI_802_11p:
            # Loss Model, parameter values from Boockmeyer, A. (2020):
            # "Hatebefi: Hybrid Application Testbed for Fault Injection"
            loss_model = propagation.ThreeLogDistancePropagationLossModel()
            loss_model.SetAttribute("Distance0", core.DoubleValue(27.3))
            loss_model.SetAttribute("Distance1", core.DoubleValue(68.4))
            loss_model.SetAttribute("Distance2", core.DoubleValue(80.7))
            loss_model.SetAttribute("Exponent0", core.DoubleValue(1.332671627050236))
            loss_model.SetAttribute("Exponent1", core.DoubleValue(2.6812446718062612))
            loss_model.SetAttribute("Exponent2", core.DoubleValue(3.5145944762444183))
            loss_model.SetAttribute("ReferenceLoss", core.DoubleValue(83.54330702928374))
            wifi_channel.SetAttribute("PropagationLossModel", core.PointerValue(loss_model))
        else:
            loss_model = propagation.LogDistancePropagationLossModel()
            wifi_channel.SetAttribute("PropagationLossModel", core.PointerValue(loss_model))

        self.wifi_phy_helper.SetChannel(wifi_channel)

        #: Helper for creating the WiFi channel.
        self.wifi = None

        #: All ns-3 devices on this channel.
        self.devices_container = None

        #: Helper for creating MAC layers.
        self.wifi_mac_helper = None

        if self.standard != WiFiChannel.WiFiStandard.WIFI_802_11p:
            self.wifi = wifi.WifiHelper()
            self.wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
                                              "DataMode", core.StringValue(self.data_rate.value),
                                              "ControlMode", core.StringValue(self.data_rate.value))
            self.wifi.SetStandard(self.standard.value)

            self.wifi_mac_helper = wifi.WifiMacHelper()

            # Adhoc network between multiple nodes (no access point).
            self.wifi_mac_helper.SetType("ns3::AdhocWifiMac")
        else:
            self.wifi = wave.Wifi80211pHelper.Default()
            self.wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
                                              "DataMode", core.StringValue(self.data_rate.value),
                                              "ControlMode", core.StringValue(self.data_rate.value),
                                              "NonUnicastMode", core.StringValue(self.data_rate.value))
            self.wifi_mac_helper = wave.NqosWaveMacHelper.Default()

        # Install on all connected nodes.
        logger.debug("Installing the WiFi channel to %d nodes. Mode is %s (data) / %s (control).", len(nodes),
                     self.standard, self.data_rate)

        #: All ns-3 devices on this channel.
        self.devices_container = self.wifi.Install(self.wifi_phy_helper, self.wifi_mac_helper, self.ns3_nodes_container)

        logger.info('Setting IP addresses on nodes.')
        stack_helper = internet.InternetStackHelper()

        for i, node in enumerate(nodes):
            ns3_device = self.devices_container.Get(i)

            address = None
            if node.wants_ip_stack():
                if node.ns3_node.GetObject(internet.Ipv4.GetTypeId()) is None:
                    logger.info('Installing IP stack on %s', node.name)
                    stack_helper.Install(node.ns3_node)
                device_container = ns_net.NetDeviceContainer(ns3_device)
                ip_address = self.network.address_helper.Assign(device_container).GetAddress(0)
                netmask = network.network.prefixlen
                address = ipaddress.ip_interface(f'{ip_address}/{netmask}')

            interface = Interface(node=node, ns3_device=ns3_device, address=address)
            ns3_device.GetMac().SetAddress(ns_net.Mac48Address(interface.mac_address))
            node.add_interface(interface)
            self.interfaces.append(interface)
Exemplo n.º 6
0
from datetime import datetime

from ns import core, internet
from pyroute2 import IPRoute

import docker

from .util import once
from .context import defer
from .workflow import Workflow
from .visualization import Visualization, NoVisualization

logger = logging.getLogger(__name__)

# This needs to be set to real time, to let the containers speek.
core.GlobalValue.Bind("SimulatorImplementationType", core.StringValue("ns3::RealtimeSimulatorImpl"))
core.GlobalValue.Bind("ChecksumEnabled", core.BooleanValue(True))
# core.LogComponentEnableAll(core.LOG_LOGIC)
# core.LogComponentEnable('TapBridge', core.LOG_DEBUG)
# core.LogComponentEnable('TapBridge', core.LOG_WARN)
# core.LogComponentEnable('MacLow', core.LOG_DEBUG)
# core.LogComponentEnable('Txop', core.LOG_DEBUG)

class Simulation:
    """ The simulation runs ns-3.
    The simulation is described by a :class:`.Scenario` which also prepares the simulation.
    It also takes care of preparing networks and nodes.

    **Do not initialize a simulation yourself.** Use the :class:`.Scenario` instead!

    Example
Exemplo n.º 7
0
from ns import core, internet
from pyroute2 import IPRoute

import docker

from .util import once
from .context import defer
from .workflow import Workflow
from .visualization import Visualization, NoVisualization

logger = logging.getLogger(__name__)

# This needs to be set to real time, to let the containers speek.
core.GlobalValue.Bind("SimulatorImplementationType",
                      core.StringValue("ns3::RealtimeSimulatorImpl"))
core.GlobalValue.Bind("ChecksumEnabled", core.BooleanValue(True))
# core.LogComponentEnableAll(core.LOG_LOGIC)
# core.LogComponentEnable('TapBridge', core.LOG_DEBUG)
# core.LogComponentEnable('TapBridge', core.LOG_WARN)
# core.LogComponentEnable('MacLow', core.LOG_DEBUG)
# core.LogComponentEnable('Txop', core.LOG_DEBUG)


class Simulation:
    """ The simulation runs ns-3.
    The simulation is described by a :class:`.Scenario` which also prepares the simulation.
    It also takes care of preparing networks and nodes.

    **Do not initialize a simulation yourself.** Use the :class:`.Scenario` instead!
Exemplo n.º 8
0
def main(li):
    p2pNodes = network.NodeContainer()
    p2pNodes.Create(2)

    pointToPoint = point_to_point.PointToPointHelper()
    pointToPoint.SetDeviceAttribute(
        "DataRate",
        core.StringValue(str(int(sum([i[0] for i in li]))) + "Mbps"))
    pointToPoint.SetChannelAttribute("Delay", core.StringValue("20ms"))

    p2pDevices = pointToPoint.Install(p2pNodes)

    csmaNodes = network.NodeContainer()
    csmaNodes.Add(p2pNodes.Get(1))
    csmaNodes.Create(3)

    csma = ccc.CsmaHelper()
    csma.SetChannelAttribute("DataRate", core.StringValue("100Mbps"))
    csma.SetChannelAttribute("Delay", core.TimeValue(core.NanoSeconds(6560)))

    csmaDevices = csma.Install(csmaNodes)

    wifiStaNodes = network.NodeContainer()
    wifiStaNodes.Create(3)
    wifiApNode = p2pNodes.Get(0)

    channel = www.YansWifiChannelHelper.Default()
    phy = www.YansWifiPhyHelper.Default()
    phy.SetChannel(channel.Create())

    wifi = www.WifiHelper()
    # wifi.SetRemoteStationManager("ns3::AarfWifiManager")
    wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager", "DataMode",
                                 core.StringValue("OfdmRate54Mbps"))

    mac = www.WifiMacHelper()
    ssid = www.Ssid("ns-3-ssid")

    mac.SetType("ns3::StaWifiMac", "Ssid", www.SsidValue(ssid),
                "ActiveProbing", core.BooleanValue(False))
    staDevices = wifi.Install(phy, mac, wifiStaNodes)

    mac.SetType("ns3::ApWifiMac", "Ssid", www.SsidValue(ssid))
    apDevices = wifi.Install(phy, mac, wifiApNode)

    mobility = mob.MobilityHelper()
    mobility.SetPositionAllocator("ns3::GridPositionAllocator", "MinX",
                                  core.DoubleValue(0.0), "MinY",
                                  core.DoubleValue(0.0), "DeltaX",
                                  core.DoubleValue(5.0), "DeltaY",
                                  core.DoubleValue(10.0), "GridWidth",
                                  core.UintegerValue(3), "LayoutType",
                                  core.StringValue("RowFirst"))
    mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel")
    mobility.Install(wifiApNode)
    mobility.Install(wifiStaNodes)

    stack = internet.InternetStackHelper()
    stack.Install(csmaNodes)
    stack.Install(wifiApNode)
    stack.Install(wifiStaNodes)

    address = internet.Ipv4AddressHelper()
    address.SetBase(network.Ipv4Address("10.1.1.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(p2pDevices)

    address.SetBase(network.Ipv4Address("10.1.2.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(csmaDevices)

    address.SetBase(network.Ipv4Address("10.1.3.0"),
                    network.Ipv4Mask("255.255.255.0"))
    address.Assign(staDevices)
    address.Assign(apDevices)

    client = csmaNodes.Get(0)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    pre = li[0]
    client.AddApplication(send(soc, pre[0], pre[1], False))
    for i in range(1, 4):
        client = csmaNodes.Get(i)
        soc = network.Socket.CreateSocket(
            client, internet.UdpSocketFactory.GetTypeId())
        pre = li[i]
        client.AddApplication(send(soc, pre[0], pre[1]))

    client = wifiStaNodes.Get(0)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    client.AddApplication(recv(soc))
    client = wifiStaNodes.Get(1)
    soc = network.Socket.CreateSocket(client,
                                      internet.UdpSocketFactory.GetTypeId())
    client.AddApplication(recv(soc, False))

    internet.Ipv4GlobalRoutingHelper.PopulateRoutingTables()

    core.Simulator.Stop(core.Seconds(3.0))

    # pointToPoint.EnablePcapAll("third")
    # phy.EnablePcapAll("csma")
    # csma.EnablePcapAll("third", True)
    # stack.EnablePcapIpv4All('ics')

    core.Simulator.Run()
    core.Simulator.Destroy()
Exemplo n.º 9
0
    def __init__(self,
                 network,
                 nodes,
                 frequency=None,
                 channel=1,
                 channel_width=40,
                 antennas=1,
                 tx_power=20.0,
                 standard: WiFiStandard = WiFiStandard.WIFI_802_11a,
                 data_rate: WiFiDataRate = WiFiDataRate.OFDM_RATE_6Mbps):
        super().__init__(network, nodes)

        #: The channel to use.
        self.channel = channel
        #: The frequency to use.
        #:
        #: This could collide with other WiFi channels.
        self.frequency = frequency
        #: The width of the channel in MHz.
        self.channel_width = channel_width
        #: The number of antennas to use.
        self.antennas = antennas
        #: The sending power in dBm.
        self.tx_power = tx_power
        #: The WiFi standard to use.
        self.standard = standard
        #: The data rate to use.
        self.data_rate = data_rate

        logger.debug("Setting up physical layer of WiFi.")
        self.wifi_phy_helper = wifi.YansWifiPhyHelper.Default()
        self.wifi_phy_helper.Set("ChannelWidth",
                                 core.UintegerValue(self.channel_width))
        if self.frequency:
            self.wifi_phy_helper.Set("Frequency",
                                     core.UintegerValue(self.frequency))
        else:
            self.wifi_phy_helper.Set("ChannelNumber",
                                     core.UintegerValue(self.channel))
        self.wifi_phy_helper.Set("Antennas", core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedTxSpatialStreams",
                                 core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("MaxSupportedRxSpatialStreams",
                                 core.UintegerValue(self.antennas))
        self.wifi_phy_helper.Set("TxPowerStart",
                                 core.DoubleValue(self.tx_power))
        self.wifi_phy_helper.Set("TxPowerEnd", core.DoubleValue(self.tx_power))

        # Enable monitoring of radio headers.
        self.wifi_phy_helper.SetPcapDataLinkType(
            wifi.WifiPhyHelper.DLT_IEEE802_11_RADIO)

        wifi_channel_helper = wifi.YansWifiChannelHelper()
        wifi_channel_helper.SetPropagationDelay(
            "ns3::ConstantSpeedPropagationDelayModel")
        wifi_channel_helper.AddPropagationLoss(
            "ns3::LogDistancePropagationLossModel")
        # wifi_channel_helper.AddPropagationLoss("ns3::RangePropagationLossModel")

        self.wifi_phy_helper.SetChannel(wifi_channel_helper.Create())

        #: Helper for creating the WiFi channel
        self.wifi = wifi.WifiHelper()
        self.wifi.SetRemoteStationManager(
            "ns3::ConstantRateWifiManager", "DataMode",
            core.StringValue(self.data_rate.value), "ControlMode",
            core.StringValue(self.data_rate.value))
        self.wifi.SetStandard(self.standard.value)

        wifi_mac_helper = wifi.WifiMacHelper()

        # Adhoc network between multiple nodes (no access point).
        wifi_mac_helper.SetType("ns3::AdhocWifiMac")

        # Install on all connected nodes.
        logger.debug(
            "Installing the WiFi channel to %d nodes. Mode is %s (data) / %s (control).",
            len(nodes), self.standard, self.data_rate)
        #: All ns-3 devices on this channel.
        self.devices_container = self.wifi.Install(self.wifi_phy_helper,
                                                   wifi_mac_helper,
                                                   self.ns3_nodes_container)

        logger.info('Setting IP addresses on nodes.')
        stack_helper = internet.InternetStackHelper()

        for i, node in enumerate(nodes):
            ns3_device = self.devices_container.Get(i)

            address = None
            if node.wants_ip_stack():
                if node.ns3_node.GetObject(internet.Ipv4.GetTypeId()) is None:
                    logger.info('Installing IP stack on %s', node.name)
                    stack_helper.Install(node.ns3_node)
                device_container = ns_net.NetDeviceContainer(ns3_device)
                ip_address = self.network.address_helper.Assign(
                    device_container).GetAddress(0)
                netmask = network.network.prefixlen
                address = ipaddress.ip_interface(f'{ip_address}/{netmask}')

            interface = Interface(node=node,
                                  ns3_device=ns3_device,
                                  address=address)
            ns3_device.GetMac().SetAddress(
                ns_net.Mac48Address(interface.mac_address))
            node.add_interface(interface)
            self.interfaces.append(interface)
Exemplo n.º 10
0
def main():
    # core.LogComponentEnable("UdpEchoClientApplication", core.LOG_LEVEL_INFO)

    wifihelper = wifi.WifiHelper.Default()
    wifihelper.SetStandard(wifi.WIFI_PHY_STANDARD_80211a)

    wifiphy = wifi.YansWifiPhyHelper.Default()
    wifichannel = wifi.YansWifiChannelHelper.Default()
    wifiphy.SetChannel(wifichannel.Create())

    wifimac = wifi.WifiMacHelper()
    wifimac.SetType("ns3::AdhocWifiMac")
    wifihelper.SetRemoteStationManager("ns3::ConstantRateWifiManager",
                                       "DataMode",
                                       core.StringValue("OfdmRate54Mbps"))

    p2pmac = p2p.PointToPointHelper()
    p2pmac.SetChannelAttribute("Delay", core.TimeValue(core.NanoSeconds(6560)))
    p2pmac.SetDeviceAttribute("DataRate", core.StringValue("2Mbps"))

    stas = network.NodeContainer()
    stas.Create(3)

    p2ps = network.NodeContainer()
    p2ps.Create(1)

    mob = mobility.MobilityHelper()
    mob.Install(stas)

    stack = internet.InternetStackHelper()
    stack.Install(stas)
    stack.Install(p2ps)

    dev = wifihelper.Install(wifiphy, wifimac, stas)
    p2ps.Add(stas.Get(0))
    dev2 = p2pmac.Install(p2ps)

    ip = internet.Ipv4AddressHelper()
    ip.SetBase(network.Ipv4Address('192.168.0.0'),
               network.Ipv4Mask('255.255.255.0'))
    ip.Assign(dev)
    ip.SetBase(network.Ipv4Address('192.168.1.0'),
               network.Ipv4Mask('255.255.255.0'))
    ip.Assign(dev2)

    client = p2ps.Get(0)
    client.AddApplication(
        aaa(
            network.Socket.CreateSocket(client,
                                        internet.UdpSocketFactory.GetTypeId()),
            0))
    for i in range(3):
        client = stas.Get(i)
        client.AddApplication(
            aaa(
                network.Socket.CreateSocket(
                    client, internet.UdpSocketFactory.GetTypeId()), i))

    internet.Ipv4GlobalRoutingHelper.PopulateRoutingTables()

    core.Simulator.Stop(core.Seconds(10.0))

    wifiphy.EnablePcapAll('adhoc', True)
    stack.EnablePcapIpv4All('ipv4')
    core.Simulator.Run()
    core.Simulator.Destroy()

    sys.exit(0)