A wireless access point device that connects wireless stations (like WirelessHost) to a wired network. Supports multiple wireless radios and multiple Ethernet ports.

Implements a highly abstracted wireless network interface (NIC) that uses a trivial MAC protocol. It offers simplicity for scenarios where Layer 1 and 2 effects can be completely ignored, for example testing the basic functionality of a wireless ad-hoc routing protocol.

This is an example queue that implements one class of the Assured Forwarding PHB group (RFC 2597).

A mobile node with the Ad hoc On-Demand Distance Vector (AODV) routing protocol. Extends AdhocHost by adding the AODV routing protocol module.

An extension of the transport layer node base that adds support for applications. Provides the highest level of abstraction for network nodes, completing the full network stack from physical to application layer.

Example IP router with BGPv4 and OSPFv4 support.

Example Ipv4 router with BGPv4 support.

Provides various layer 2 services such as packet forwarding, interface selection, virtual LAN handling, stream handling.

Definition of an IP node with a transport generator that connects to IP directly, without TCP or UDP.

Mixes two different packet sources to generate bursty traffic.

Implements a prioritized queue system for IEEE 802.11 MAC frames. Uses a classifier to separate incoming packets into three queues: management frames (highest priority), multicast frames (medium priority), and unicast frames (lowest priority). A priority scheduler then selects packets from these queues in order of priority.

This is an example queue that can be used in interfaces of DS core and edge nodes to support the AFxy (RFC 2597) and EF (RFC 3246) PHBs.

TODO documentation

Provides a layer that combines the decision for local delivery with the service of reversing the direction of an incoming packet to outgoing for packet forwarding.

A mobile node with the Destination-Sequenced Distance Vector (DSDV) routing protocol. Extends AdhocHost by adding the DSDV routing protocol module.

Diffserv Queue used in Experiment 1.1 - 1.6 and 5.1.

Diffserv Queue used in Experiment 2.1 - 2.4.

Combines two meters and their corresponding filters per path. This is primarily useful for combining a token bucket based metering with an asynchronous packet shaper. Note that the asynchronous packet shaper also has parts in the network interface queue module.

A mobile node with the Dynamic MANET On-demand (DYMO) routing protocol. Extends AdhocHost by adding the DYMO routing protocol module.

Generates traffic as an Ethernet application. The traffic source and traffic sink modules can be built from queueing model elements.

A simplified network device that communicates directly over Ethernet without higher layer protocols like IP or TCP. It provides a basic host model for Ethernet-only simulations.

An example host with one Ethernet interface and an Ethernet traffic generator directly connected to it. This host model does not contain higher layer protocols (IP, TCP). By default is configured to use half-duplex MAC (CSMA/CD).

Represents an Ethernet network interface.

Implements a network interface that is suitable for use in Ethernet 10BASE-T1S multidrop links. Such a multidrop link uses the Ethernet Phyisical Layer Collision Avoidance (PLCA) protocol. The protocol is defined in the IEEE 802.3cg-2019 standard. This network interface can be used in any network node module (e.g. ~StandardHost) that allows replacing its network interfaces. All network interfaces on the same multidrop link must use this module.

Queue module that gives the PAUSE frames a higher priority, and can be parametrized with an ~IPacketQueue for serving the data frames.

Queue module that gives the PAUSE frames a higher priority, and using Random Early Detection algorithm on data frames, and can be parametrized with an ~IPacketQueue for serving the data frames.

EthernetSwitch models a Layer 2 Ethernet switch with support for various IEEE 802.1 protocols and features. It provides frame forwarding based on MAC addresses and implements multiple switching technologies.

Provides an Ethernet network interface suitable for emulation. The lower part of the network interface is realized in the real world using a real Ethernet socket of the host computer which is running the simulation.

Provides IPv4 layer functionality for network emulation that connects the simulation to a real network on the host computer. Sends packets from the simulation to the real network and receives packets from the real network into the simulation using raw sockets. Uses ~Ipv4Encap for packet encapsulation and ~ExtIpv4Socket for the connection to the host's networking stack.

Provides a simplified network layer for emulation that connects the simulation to a real network on the host computer. Uses ~ExtLowerIpv4 to send packets from the simulation to the real network and receive packets from the real network into the simulation using raw sockets.

Provides an Ethernet network interface suitable for emulation. The upper part of the network interface is realized in the real world using a real TAP device of the host computer which is running the simulation.

Provides an IEEE 802.11 network interface suitable for emulation. The upper part of the network interface is realized in the real world using a real TAP device of the host computer which is running the simulation.

Provides IPv4 layer functionality for network emulation that connects simulated applications to a real network on the host computer. Uses a real TUN device on the host OS to capture and inject packets at the IP layer, allowing simulated applications to communicate with real-world network endpoints through the host's networking stack.

Provides a network layer that connects the simulation to a real network on the host computer using a TUN device. Allows simulated applications to send and receive packets through the host's networking stack at the IP layer. Contains standard components like routing table and ARP, and uses ~ExtUpperIpv4 with a TUN device for external connectivity.

Implements a priority queue with multiple inner queues each having its own periodic gate for packet selection and an optional shared memory buffer.

Implements a queue having its own periodic gate.

A mobile node with the Greedy Perimeter Stateless Routing (GPSR) protocol. It extends AdhocHost by adding the GPSR routing protocol module.

Implements a gPTP end station that contains a clock module and a gPTP protocol.

Implements an IEEE 802.11 network interface. It implements a large subset of the IEEE 802.11 standard, and may use radio models and wireless signal representations of varying levels of detail. It is also extremely configurable, and its component structure makes it easy to experiment with various details of the protocol.

Implements an IEEE 802.15.4 narrowband network interface.

Implements an IEEE 802.15.4 UWB-IR network interface.

Implements the IEEE 802.1Q per-stream filtering and policing. The relationship between streams, gates, and meters is not one-to-one. The number of streams, gates, and meters can be different, and the module will take care of the connections between the submodules based on the streamFilterTable parameter.

Implements IEEE 802.1Q protocol functionality as a layered architecture with policy and protocol components. The policy submodule handles VLAN filtering and mapping, while the protocol submodule manages tag encapsulation/ decapsulation. Supports both C-VLAN (0x8100) and S-VLAN (0x88A8) tag types through configuration. Enables network segmentation and traffic control in Ethernet networks by processing VLAN tags according to configured policies.

Implements the IEEE 802.1Q protocol encapsulation/decapsulation. It also provides socket support so applications can use the protocol directly.

Implements the IEEE 802.1Q time aware shaper.

Implements the IEEE 802.1r protocol encapsulation/decapsulation.

Generates traffic as an IEEE 802.2 LLC application. The traffic source and traffic sink modules can be built from queueing model elements.

Combines the interface MAC address learning from incoming packets with the outgoing interface selection for outgoing packets into a single layer.

Generates traffic for a IP application. The traffic source and traffic sink modules can be built from queueing model elements.

Several hosts and an Ethernet hub on a switch. One port of the hub connect to a 10Base2 segment.

Several hosts and a router on an Ethernet hub and a switch

Network(1,2,3,4) layer of an IPv4 node.

Several hosts on a router; part of ~IPv4LargeNet.

Represents an IPv6 network layer (L3).

Several hosts and an Ethernet hub on a switch. One port of the hub connect to a 10Base2 segment. Part of ~LargeNet(1,2).

Implements an Ethernet network interface.

An LDP-capable router.

Implements a parameterizable leaky bucket algorithm.

An extension of the basic node infrastructure with link layer functionality. Provides support for various network interfaces and link layer protocols, forming the foundation for network connectivity.

Implements a loopback network interface.

A mobile node with ad hoc routing capabilities intended for Mobile Ad hoc Networks (MANETs). Extends AdhocHost by adding support for MANET routing protocols.

Several hosts and an Ethernet hub on a switch; part of ~LargeNet(1,2).

Combines multiple ~Gptp modules, one per time domain into a multi time domain time synchronization module. Each gPTP time domain is automatically configured to use the corresponding subclock of the clock passed into this module.

Combines multiple packet filters into one.

Combines multiple packet meters into one.

Combines multiple packet policing modules into one.

An extension of the link layer node base with network layer functionality. Provides support for multiple network protocols, including IPv4 and IPv6.

Provides a network layer for the next hop forwarding.

Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given by the interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialize.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialize.

Implements the module given an interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an optional module that removes itself from the module hierarchy during initialize.

Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the given interface and can be used as an optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialize.

Implements the given module interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the module given interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.

Implements the OSPFv3 (Open Shortest Path First version 3) routing protocol for IPv4 and IPv6 networks. This module supports dynamic routing based on link state advertisements, allowing routers to discover and maintain routes to all destinations in an autonomous system.

Connects one packet producer to one packet consumer. It can be pushed with packets from the connected packet producer. It keeps a copy of the last N packets pushed into its input. The packets are available in the runtime user interface (Qtenv) for inspection.

Combines a packet meter and a packet filter into a packet policing module. The meter measures the packet flow that is passing through and attaches some meta information to the packets. The filter drops the packets that do not match the implemented filter criteria.

Combines a packet queue and a packet gate into a packet shaper module. The queue stores the packets sorted according to its ordering and the gate decides when the first packet can be pulled from the queue.

Implements the Protocol Independent Multicast (PIM) routing protocol for IP multicast. This module integrates both PIM-DM (Dense Mode) and PIM-SM (Sparse Mode) implementations, using a splitter to direct packets to the appropriate mode based on interface configuration. PIM builds distribution trees for efficient multicast data delivery across IP networks.

Implements a PPP network interface.

Implements a priority queue with multiple inner queues and an optional shared memory buffer.

Combines a classifier, a scheduler, and several traffic shapers into a single packet shaper. Packets are classified into one of the traffic shapers, and the scheduler prioritizes among them.

Produces packets in order to prevent a queue from becoming empty.

Compound module that delays packets for a specified amount of time while preserving their order. Implements the IPacketDelayer interface using a queue and server architecture. The queue stores packets while they wait, and the server processes each packet with a processing time equal to the configured delay. Note that the actual packet delay will be the sum of the queueing time and the configured delay. Unlike the simple PacketDelayer module, this implementation always maintains packet order regardless of delay distribution.

Combines a packet queue with random early detection (RED) dropper.

Processes incoming packets one by one in the order they arrive. First, it classifies a packet according to the configured classifier function, then it generates tokens for the selected category in the configured response producer.

Generates several different streams of packets, one after the other. For each traffic category, the packets are produced by a separate token-based server. The traffic stream can be started by adding tokens to the corresponding server module. The packet data, packet length, and timing distributions can be configured in the corresponding packet provider.

A network router device with support for multiple routing protocols and network interfaces. Provides the foundation for simulating various types of routers in both wired and wireless networks.

An RSVP-TE capable router.

A network node with Real-time Transport Protocol (RTP) support. Extends StandardHost by adding RTP-specific components for real-time multimedia streaming applications.

Implements a simplified version of the IEEE 802.1Q per-stream filtering and policing. Each filtered stream has its own path where metering and filtering happens independently of any other stream.

Provides a simple network layer.

Implements a generic sink application.

Several hosts on an Ethernet hub; part of ~LargeNet(1,2).

Implements a generic source application.

Combines a stream decoder and a stream encoder into a layer. For incoming packets, the stream decoder determines the stream of the packet. For outgoing packets, the stream encoder determines the VLAN id, etc. of the packet.

Combines two packet filters into a protocol layer so that it can be used in a layered compound module. There are separate submodules for ingress and egress traffic, but in most cases only the ingress filter is used.

Wraps a stream identifier into a protocol layer so that it can be used in a layered compound module.

Combines a stream merger and a stream splitter module into a stream relay layer. For incoming packets, the identified streams are merged by the stream merger. For outgoing packets, the requested streams are split by the stream splitter.

Traffic conditioner used in Experiments 1.1-1.6 and 5.1.

Traffic conditioner used in Experiment 3.1.

Traffic conditioner used in Experiment 3.2.

A generic, very modular TCP client application, similar to ~TcpServerApp. The traffic source and traffic sink modules can be built from queueing model elements.

A generic, modular TCP server application. It is composed of a listener module that listens on a port to accept TCP connections, and for each incoming TCP connection it dynamically creates a new module in the connection[] submodule vector to handle the connection.

This is a pre-assembled module type to be used in ~TcpServerApp. One instance of this module type is launched by ~TcpServerListener for each incoming connection. It is composed of a traffic source, a traffic sink, a socket I/O and other modules, and most of the module types are parametric. The traffic source and traffic sink modules can be built from queueing model elements.

This client application contains a configurable pre-composed telnet traffic source and traffic sink.

Contains a configurable pre-composed telnet traffic source and traffic sink as part of a telnet server application.

Implements a parameterizable token bucket algorithm.

TODO documentation

An extension of the network layer node base with transport layer protocols. Provides support for UDP, TCP, and SCTP, enabling end-to-end communication services for applications.

Implements a (simulated) TUN network interface.

Generates traffic for a UDP application. The traffic source and traffic sink modules can be built from queueing model elements.

Implements a virtual network interface.

Several hosts and an Ethernet hub on a switch. One port of the hub connect to a 10Base2 segment.

Several hosts and an Ethernet hub on a switch

Several hosts on an Ethernet hub

Well, this models a 802.11 Access Point with a Sink.

Implements a generic wireless network interface.

Provides a simple network layer.

Implements xMIPv6 (where x = F, H, F-H).