Network

Package: inet.examples.pim.iptv

Network

network

A generated network with grid topology.

R00 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R00: MulticastRouter { @display("p=400,100"); gates: ethg[4]; } R01 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R01: MulticastRouter { @display("p=400,190"); gates: ethg[4]; } R02 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R02: MulticastRouter { @display("p=400,280"); gates: ethg[4]; } R03 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R03: MulticastRouter { @display("p=400,370"); gates: ethg[4]; } R10 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R10: MulticastRouter { @display("p=550,100"); gates: ethg[4]; } R11 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R11: MulticastRouter { @display("p=550,190"); gates: ethg[4]; } R12 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R12: MulticastRouter { @display("p=550,280"); gates: ethg[4]; } R13 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R13: MulticastRouter { @display("p=550,370"); gates: ethg[4]; } R20 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R20: MulticastRouter { @display("p=700,100"); gates: ethg[4]; } R21 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R21: MulticastRouter { @display("p=700,190"); gates: ethg[4]; } R22 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R22: MulticastRouter { @display("p=700,280"); gates: ethg[4]; } R23 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R23: MulticastRouter { @display("p=700,370"); gates: ethg[4]; } R30 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R30: MulticastRouter { @display("p=850,100"); gates: ethg[4]; } R31 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R31: MulticastRouter { @display("p=850,190"); gates: ethg[4]; } R32 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R32: MulticastRouter { @display("p=850,280"); gates: ethg[4]; } R33 : MulticastRouter A router with multicast routing capabilities that can forward multicast traffic between different... Source: R33: MulticastRouter { @display("p=850,370"); gates: ethg[4]; } configurator : Ipv4NetworkConfigurator Assigns IPv4 addresses and sets up static routing for an IPv4 network. Source: configurator: Ipv4NetworkConfigurator { @display("p=100,100;is=s"); } client : StandardHost A comprehensive model of an IPv4/IPv6 host that provides a complete network stack with configurable... Source: client: StandardHost { @display("p=1000,370"); } server : StandardHost A comprehensive model of an IPv4/IPv6 host that provides a complete network stack with configurable... Source: server: StandardHost { @display("p=250,100"); }

Usage diagram

The following diagram shows usage relationships between types. Unresolved types are missing from the diagram.

Properties

Name Value Description
isNetwork

Unassigned submodule parameters

Name Type Default value Description
R00.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.status.initialStatus string "UP"

TODO @signal, @statistic
R00.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.environment.initStage int 0

Initialization stage for the setup command
R00.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R00.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R00.environment.setupCommand string ""

A host OS system command
R00.environment.teardownCommand string ""

A host OS system command
R00.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.pcapRecorder.verbose bool true

Whether to log packets on the module output
R00.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R00.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R00.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R00.pcapRecorder.fileFormat string "pcapng"
R00.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R00.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R00.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R00.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R00.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R00.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R00.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R00.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R00.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R00.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R00.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R00.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.cb.forwardServiceRegistration bool true
R00.cb.forwardProtocolRegistration bool true
R00.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.bl.forwardServiceRegistration bool true
R00.bl.forwardProtocolRegistration bool true
R00.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.li.forwardServiceRegistration bool true
R00.li.forwardProtocolRegistration bool true
R00.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.eth.bitrate double
R00.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.nl.forwardServiceRegistration bool true
R00.nl.forwardProtocolRegistration bool true
R00.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.tn.forwardServiceRegistration bool true
R00.tn.forwardProtocolRegistration bool true
R00.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R00.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R00.at.forwardServiceRegistration bool true
R00.at.forwardProtocolRegistration bool true
R00.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R00.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R00.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R00.bgp.interfaceTableModule string

The path to the InterfaceTable module
R00.bgp.routingTableModule string
R00.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R01.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.status.initialStatus string "UP"

TODO @signal, @statistic
R01.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.environment.initStage int 0

Initialization stage for the setup command
R01.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R01.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R01.environment.setupCommand string ""

A host OS system command
R01.environment.teardownCommand string ""

A host OS system command
R01.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.pcapRecorder.verbose bool true

Whether to log packets on the module output
R01.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R01.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R01.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R01.pcapRecorder.fileFormat string "pcapng"
R01.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R01.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R01.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R01.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R01.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R01.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R01.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R01.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R01.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R01.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R01.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R01.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.cb.forwardServiceRegistration bool true
R01.cb.forwardProtocolRegistration bool true
R01.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.bl.forwardServiceRegistration bool true
R01.bl.forwardProtocolRegistration bool true
R01.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.li.forwardServiceRegistration bool true
R01.li.forwardProtocolRegistration bool true
R01.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.eth.bitrate double
R01.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.nl.forwardServiceRegistration bool true
R01.nl.forwardProtocolRegistration bool true
R01.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.tn.forwardServiceRegistration bool true
R01.tn.forwardProtocolRegistration bool true
R01.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R01.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R01.at.forwardServiceRegistration bool true
R01.at.forwardProtocolRegistration bool true
R01.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R01.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R01.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R01.bgp.interfaceTableModule string

The path to the InterfaceTable module
R01.bgp.routingTableModule string
R01.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R02.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.status.initialStatus string "UP"

TODO @signal, @statistic
R02.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.environment.initStage int 0

Initialization stage for the setup command
R02.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R02.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R02.environment.setupCommand string ""

A host OS system command
R02.environment.teardownCommand string ""

A host OS system command
R02.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.pcapRecorder.verbose bool true

Whether to log packets on the module output
R02.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R02.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R02.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R02.pcapRecorder.fileFormat string "pcapng"
R02.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R02.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R02.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R02.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R02.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R02.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R02.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R02.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R02.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R02.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R02.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R02.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.cb.forwardServiceRegistration bool true
R02.cb.forwardProtocolRegistration bool true
R02.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.bl.forwardServiceRegistration bool true
R02.bl.forwardProtocolRegistration bool true
R02.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.li.forwardServiceRegistration bool true
R02.li.forwardProtocolRegistration bool true
R02.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.eth.bitrate double
R02.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.nl.forwardServiceRegistration bool true
R02.nl.forwardProtocolRegistration bool true
R02.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.tn.forwardServiceRegistration bool true
R02.tn.forwardProtocolRegistration bool true
R02.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R02.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R02.at.forwardServiceRegistration bool true
R02.at.forwardProtocolRegistration bool true
R02.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R02.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R02.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R02.bgp.interfaceTableModule string

The path to the InterfaceTable module
R02.bgp.routingTableModule string
R02.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R03.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.status.initialStatus string "UP"

TODO @signal, @statistic
R03.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.environment.initStage int 0

Initialization stage for the setup command
R03.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R03.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R03.environment.setupCommand string ""

A host OS system command
R03.environment.teardownCommand string ""

A host OS system command
R03.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.pcapRecorder.verbose bool true

Whether to log packets on the module output
R03.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R03.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R03.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R03.pcapRecorder.fileFormat string "pcapng"
R03.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R03.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R03.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R03.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R03.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R03.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R03.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R03.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R03.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R03.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R03.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R03.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.cb.forwardServiceRegistration bool true
R03.cb.forwardProtocolRegistration bool true
R03.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.bl.forwardServiceRegistration bool true
R03.bl.forwardProtocolRegistration bool true
R03.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.li.forwardServiceRegistration bool true
R03.li.forwardProtocolRegistration bool true
R03.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.eth.bitrate double
R03.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.nl.forwardServiceRegistration bool true
R03.nl.forwardProtocolRegistration bool true
R03.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.tn.forwardServiceRegistration bool true
R03.tn.forwardProtocolRegistration bool true
R03.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R03.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R03.at.forwardServiceRegistration bool true
R03.at.forwardProtocolRegistration bool true
R03.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R03.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R03.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R03.bgp.interfaceTableModule string

The path to the InterfaceTable module
R03.bgp.routingTableModule string
R03.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R10.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.status.initialStatus string "UP"

TODO @signal, @statistic
R10.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.environment.initStage int 0

Initialization stage for the setup command
R10.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R10.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R10.environment.setupCommand string ""

A host OS system command
R10.environment.teardownCommand string ""

A host OS system command
R10.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.pcapRecorder.verbose bool true

Whether to log packets on the module output
R10.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R10.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R10.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R10.pcapRecorder.fileFormat string "pcapng"
R10.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R10.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R10.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R10.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R10.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R10.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R10.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R10.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R10.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R10.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R10.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R10.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.cb.forwardServiceRegistration bool true
R10.cb.forwardProtocolRegistration bool true
R10.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.bl.forwardServiceRegistration bool true
R10.bl.forwardProtocolRegistration bool true
R10.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.li.forwardServiceRegistration bool true
R10.li.forwardProtocolRegistration bool true
R10.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.eth.bitrate double
R10.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.nl.forwardServiceRegistration bool true
R10.nl.forwardProtocolRegistration bool true
R10.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.tn.forwardServiceRegistration bool true
R10.tn.forwardProtocolRegistration bool true
R10.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R10.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R10.at.forwardServiceRegistration bool true
R10.at.forwardProtocolRegistration bool true
R10.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R10.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R10.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R10.bgp.interfaceTableModule string

The path to the InterfaceTable module
R10.bgp.routingTableModule string
R10.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R11.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.status.initialStatus string "UP"

TODO @signal, @statistic
R11.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.environment.initStage int 0

Initialization stage for the setup command
R11.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R11.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R11.environment.setupCommand string ""

A host OS system command
R11.environment.teardownCommand string ""

A host OS system command
R11.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.pcapRecorder.verbose bool true

Whether to log packets on the module output
R11.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R11.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R11.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R11.pcapRecorder.fileFormat string "pcapng"
R11.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R11.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R11.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R11.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R11.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R11.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R11.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R11.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R11.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R11.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R11.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R11.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.cb.forwardServiceRegistration bool true
R11.cb.forwardProtocolRegistration bool true
R11.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.bl.forwardServiceRegistration bool true
R11.bl.forwardProtocolRegistration bool true
R11.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.li.forwardServiceRegistration bool true
R11.li.forwardProtocolRegistration bool true
R11.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.eth.bitrate double
R11.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.nl.forwardServiceRegistration bool true
R11.nl.forwardProtocolRegistration bool true
R11.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.tn.forwardServiceRegistration bool true
R11.tn.forwardProtocolRegistration bool true
R11.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R11.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R11.at.forwardServiceRegistration bool true
R11.at.forwardProtocolRegistration bool true
R11.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R11.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R11.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R11.bgp.interfaceTableModule string

The path to the InterfaceTable module
R11.bgp.routingTableModule string
R11.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R12.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.status.initialStatus string "UP"

TODO @signal, @statistic
R12.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.environment.initStage int 0

Initialization stage for the setup command
R12.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R12.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R12.environment.setupCommand string ""

A host OS system command
R12.environment.teardownCommand string ""

A host OS system command
R12.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.pcapRecorder.verbose bool true

Whether to log packets on the module output
R12.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R12.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R12.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R12.pcapRecorder.fileFormat string "pcapng"
R12.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R12.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R12.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R12.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R12.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R12.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R12.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R12.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R12.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R12.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R12.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R12.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.cb.forwardServiceRegistration bool true
R12.cb.forwardProtocolRegistration bool true
R12.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.bl.forwardServiceRegistration bool true
R12.bl.forwardProtocolRegistration bool true
R12.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.li.forwardServiceRegistration bool true
R12.li.forwardProtocolRegistration bool true
R12.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.eth.bitrate double
R12.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.nl.forwardServiceRegistration bool true
R12.nl.forwardProtocolRegistration bool true
R12.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.tn.forwardServiceRegistration bool true
R12.tn.forwardProtocolRegistration bool true
R12.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R12.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R12.at.forwardServiceRegistration bool true
R12.at.forwardProtocolRegistration bool true
R12.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R12.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R12.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R12.bgp.interfaceTableModule string

The path to the InterfaceTable module
R12.bgp.routingTableModule string
R12.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R13.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.status.initialStatus string "UP"

TODO @signal, @statistic
R13.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.environment.initStage int 0

Initialization stage for the setup command
R13.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R13.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R13.environment.setupCommand string ""

A host OS system command
R13.environment.teardownCommand string ""

A host OS system command
R13.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.pcapRecorder.verbose bool true

Whether to log packets on the module output
R13.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R13.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R13.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R13.pcapRecorder.fileFormat string "pcapng"
R13.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R13.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R13.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R13.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R13.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R13.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R13.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R13.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R13.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R13.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R13.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R13.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.cb.forwardServiceRegistration bool true
R13.cb.forwardProtocolRegistration bool true
R13.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.bl.forwardServiceRegistration bool true
R13.bl.forwardProtocolRegistration bool true
R13.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.li.forwardServiceRegistration bool true
R13.li.forwardProtocolRegistration bool true
R13.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.eth.bitrate double
R13.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.nl.forwardServiceRegistration bool true
R13.nl.forwardProtocolRegistration bool true
R13.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.tn.forwardServiceRegistration bool true
R13.tn.forwardProtocolRegistration bool true
R13.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R13.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R13.at.forwardServiceRegistration bool true
R13.at.forwardProtocolRegistration bool true
R13.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R13.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R13.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R13.bgp.interfaceTableModule string

The path to the InterfaceTable module
R13.bgp.routingTableModule string
R13.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R20.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.status.initialStatus string "UP"

TODO @signal, @statistic
R20.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.environment.initStage int 0

Initialization stage for the setup command
R20.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R20.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R20.environment.setupCommand string ""

A host OS system command
R20.environment.teardownCommand string ""

A host OS system command
R20.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.pcapRecorder.verbose bool true

Whether to log packets on the module output
R20.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R20.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R20.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R20.pcapRecorder.fileFormat string "pcapng"
R20.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R20.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R20.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R20.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R20.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R20.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R20.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R20.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R20.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R20.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R20.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R20.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.cb.forwardServiceRegistration bool true
R20.cb.forwardProtocolRegistration bool true
R20.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.bl.forwardServiceRegistration bool true
R20.bl.forwardProtocolRegistration bool true
R20.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.li.forwardServiceRegistration bool true
R20.li.forwardProtocolRegistration bool true
R20.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.eth.bitrate double
R20.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.nl.forwardServiceRegistration bool true
R20.nl.forwardProtocolRegistration bool true
R20.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.tn.forwardServiceRegistration bool true
R20.tn.forwardProtocolRegistration bool true
R20.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R20.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R20.at.forwardServiceRegistration bool true
R20.at.forwardProtocolRegistration bool true
R20.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R20.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R20.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R20.bgp.interfaceTableModule string

The path to the InterfaceTable module
R20.bgp.routingTableModule string
R20.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R21.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.status.initialStatus string "UP"

TODO @signal, @statistic
R21.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.environment.initStage int 0

Initialization stage for the setup command
R21.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R21.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R21.environment.setupCommand string ""

A host OS system command
R21.environment.teardownCommand string ""

A host OS system command
R21.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.pcapRecorder.verbose bool true

Whether to log packets on the module output
R21.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R21.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R21.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R21.pcapRecorder.fileFormat string "pcapng"
R21.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R21.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R21.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R21.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R21.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R21.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R21.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R21.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R21.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R21.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R21.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R21.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.cb.forwardServiceRegistration bool true
R21.cb.forwardProtocolRegistration bool true
R21.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.bl.forwardServiceRegistration bool true
R21.bl.forwardProtocolRegistration bool true
R21.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.li.forwardServiceRegistration bool true
R21.li.forwardProtocolRegistration bool true
R21.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.eth.bitrate double
R21.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.nl.forwardServiceRegistration bool true
R21.nl.forwardProtocolRegistration bool true
R21.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.tn.forwardServiceRegistration bool true
R21.tn.forwardProtocolRegistration bool true
R21.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R21.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R21.at.forwardServiceRegistration bool true
R21.at.forwardProtocolRegistration bool true
R21.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R21.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R21.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R21.bgp.interfaceTableModule string

The path to the InterfaceTable module
R21.bgp.routingTableModule string
R21.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R22.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.status.initialStatus string "UP"

TODO @signal, @statistic
R22.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.environment.initStage int 0

Initialization stage for the setup command
R22.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R22.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R22.environment.setupCommand string ""

A host OS system command
R22.environment.teardownCommand string ""

A host OS system command
R22.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.pcapRecorder.verbose bool true

Whether to log packets on the module output
R22.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R22.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R22.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R22.pcapRecorder.fileFormat string "pcapng"
R22.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R22.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R22.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R22.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R22.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R22.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R22.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R22.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R22.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R22.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R22.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R22.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.cb.forwardServiceRegistration bool true
R22.cb.forwardProtocolRegistration bool true
R22.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.bl.forwardServiceRegistration bool true
R22.bl.forwardProtocolRegistration bool true
R22.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.li.forwardServiceRegistration bool true
R22.li.forwardProtocolRegistration bool true
R22.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.eth.bitrate double
R22.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.nl.forwardServiceRegistration bool true
R22.nl.forwardProtocolRegistration bool true
R22.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.tn.forwardServiceRegistration bool true
R22.tn.forwardProtocolRegistration bool true
R22.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R22.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R22.at.forwardServiceRegistration bool true
R22.at.forwardProtocolRegistration bool true
R22.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R22.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R22.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R22.bgp.interfaceTableModule string

The path to the InterfaceTable module
R22.bgp.routingTableModule string
R22.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R23.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.status.initialStatus string "UP"

TODO @signal, @statistic
R23.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.environment.initStage int 0

Initialization stage for the setup command
R23.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R23.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R23.environment.setupCommand string ""

A host OS system command
R23.environment.teardownCommand string ""

A host OS system command
R23.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.pcapRecorder.verbose bool true

Whether to log packets on the module output
R23.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R23.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R23.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R23.pcapRecorder.fileFormat string "pcapng"
R23.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R23.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R23.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R23.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R23.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R23.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R23.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R23.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R23.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R23.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R23.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R23.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.cb.forwardServiceRegistration bool true
R23.cb.forwardProtocolRegistration bool true
R23.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.bl.forwardServiceRegistration bool true
R23.bl.forwardProtocolRegistration bool true
R23.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.li.forwardServiceRegistration bool true
R23.li.forwardProtocolRegistration bool true
R23.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.eth.bitrate double
R23.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.nl.forwardServiceRegistration bool true
R23.nl.forwardProtocolRegistration bool true
R23.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.tn.forwardServiceRegistration bool true
R23.tn.forwardProtocolRegistration bool true
R23.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R23.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R23.at.forwardServiceRegistration bool true
R23.at.forwardProtocolRegistration bool true
R23.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R23.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R23.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R23.bgp.interfaceTableModule string

The path to the InterfaceTable module
R23.bgp.routingTableModule string
R23.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R30.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.status.initialStatus string "UP"

TODO @signal, @statistic
R30.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.environment.initStage int 0

Initialization stage for the setup command
R30.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R30.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R30.environment.setupCommand string ""

A host OS system command
R30.environment.teardownCommand string ""

A host OS system command
R30.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.pcapRecorder.verbose bool true

Whether to log packets on the module output
R30.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R30.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R30.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R30.pcapRecorder.fileFormat string "pcapng"
R30.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R30.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R30.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R30.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R30.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R30.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R30.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R30.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R30.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R30.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R30.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R30.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.cb.forwardServiceRegistration bool true
R30.cb.forwardProtocolRegistration bool true
R30.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.bl.forwardServiceRegistration bool true
R30.bl.forwardProtocolRegistration bool true
R30.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.li.forwardServiceRegistration bool true
R30.li.forwardProtocolRegistration bool true
R30.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.eth.bitrate double
R30.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.nl.forwardServiceRegistration bool true
R30.nl.forwardProtocolRegistration bool true
R30.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.tn.forwardServiceRegistration bool true
R30.tn.forwardProtocolRegistration bool true
R30.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R30.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R30.at.forwardServiceRegistration bool true
R30.at.forwardProtocolRegistration bool true
R30.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R30.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R30.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R30.bgp.interfaceTableModule string

The path to the InterfaceTable module
R30.bgp.routingTableModule string
R30.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R31.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.status.initialStatus string "UP"

TODO @signal, @statistic
R31.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.environment.initStage int 0

Initialization stage for the setup command
R31.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R31.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R31.environment.setupCommand string ""

A host OS system command
R31.environment.teardownCommand string ""

A host OS system command
R31.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.pcapRecorder.verbose bool true

Whether to log packets on the module output
R31.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R31.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R31.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R31.pcapRecorder.fileFormat string "pcapng"
R31.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R31.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R31.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R31.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R31.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R31.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R31.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R31.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R31.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R31.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R31.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R31.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.cb.forwardServiceRegistration bool true
R31.cb.forwardProtocolRegistration bool true
R31.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.bl.forwardServiceRegistration bool true
R31.bl.forwardProtocolRegistration bool true
R31.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.li.forwardServiceRegistration bool true
R31.li.forwardProtocolRegistration bool true
R31.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.eth.bitrate double
R31.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.nl.forwardServiceRegistration bool true
R31.nl.forwardProtocolRegistration bool true
R31.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.tn.forwardServiceRegistration bool true
R31.tn.forwardProtocolRegistration bool true
R31.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R31.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R31.at.forwardServiceRegistration bool true
R31.at.forwardProtocolRegistration bool true
R31.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R31.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R31.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R31.bgp.interfaceTableModule string

The path to the InterfaceTable module
R31.bgp.routingTableModule string
R31.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R32.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.status.initialStatus string "UP"

TODO @signal, @statistic
R32.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.environment.initStage int 0

Initialization stage for the setup command
R32.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R32.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R32.environment.setupCommand string ""

A host OS system command
R32.environment.teardownCommand string ""

A host OS system command
R32.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.pcapRecorder.verbose bool true

Whether to log packets on the module output
R32.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R32.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R32.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R32.pcapRecorder.fileFormat string "pcapng"
R32.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R32.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R32.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R32.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R32.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R32.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R32.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R32.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R32.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R32.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R32.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R32.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.cb.forwardServiceRegistration bool true
R32.cb.forwardProtocolRegistration bool true
R32.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.bl.forwardServiceRegistration bool true
R32.bl.forwardProtocolRegistration bool true
R32.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.li.forwardServiceRegistration bool true
R32.li.forwardProtocolRegistration bool true
R32.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.eth.bitrate double
R32.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.nl.forwardServiceRegistration bool true
R32.nl.forwardProtocolRegistration bool true
R32.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.tn.forwardServiceRegistration bool true
R32.tn.forwardProtocolRegistration bool true
R32.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R32.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R32.at.forwardServiceRegistration bool true
R32.at.forwardProtocolRegistration bool true
R32.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R32.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R32.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R32.bgp.interfaceTableModule string

The path to the InterfaceTable module
R32.bgp.routingTableModule string
R32.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
R33.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.status.initialStatus string "UP"

TODO @signal, @statistic
R33.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.environment.initStage int 0

Initialization stage for the setup command
R33.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
R33.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
R33.environment.setupCommand string ""

A host OS system command
R33.environment.teardownCommand string ""

A host OS system command
R33.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.pcapRecorder.verbose bool true

Whether to log packets on the module output
R33.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
R33.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
R33.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
R33.pcapRecorder.fileFormat string "pcapng"
R33.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
R33.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
R33.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
R33.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
R33.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
R33.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
R33.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
R33.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
R33.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
R33.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
R33.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
R33.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.cb.forwardServiceRegistration bool true
R33.cb.forwardProtocolRegistration bool true
R33.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.bl.forwardServiceRegistration bool true
R33.bl.forwardProtocolRegistration bool true
R33.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.li.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.li.forwardServiceRegistration bool true
R33.li.forwardProtocolRegistration bool true
R33.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.eth.bitrate double
R33.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.nl.forwardServiceRegistration bool true
R33.nl.forwardProtocolRegistration bool true
R33.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.tn.forwardServiceRegistration bool true
R33.tn.forwardProtocolRegistration bool true
R33.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
R33.at.interfaceTableModule string

Module path to the ~InterfaceTable module
R33.at.forwardServiceRegistration bool true
R33.at.forwardProtocolRegistration bool true
R33.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
R33.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
R33.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
R33.bgp.interfaceTableModule string

The path to the InterfaceTable module
R33.bgp.routingTableModule string
R33.bgp.ospfRoutingModule string parent.hasOspf ? "^.ospf" : ""
configurator.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
configurator.minLinkWeight double 1E-3
configurator.configureIsolatedNetworksSeparatly bool false
configurator.config xml xml("")

XML configuration parameters for IP address assignment and adding manual routes
configurator.assignAddresses bool true

Assign IP addresses to all interfaces in the network
configurator.assignUniqueAddresses bool true

Avoid using the same address and raise an error if not possible
configurator.assignDisjunctSubnetAddresses bool true

Avoid using the same address prefix and netmask on different links when assigning IP addresses to interfaces
configurator.addStaticRoutes bool true

Add static routes to the routing tables of all nodes to route to all destination interfaces (only where applicable; turn off when config file contains manual routes)
configurator.addDefaultRoutes bool true

Add default routes if all routes from a source node go through the same gateway (used only if addStaticRoutes is true)
configurator.addSubnetRoutes bool true

Add subnet routes instead of destination interface routes (only where applicable; used only if addStaticRoutes is true)
configurator.addDirectRoutes bool true

Add direct routes towards local network members (i.e. directly connected interfaces) to the routing table (used only if addStaticRoutes is true)
configurator.optimizeRoutes bool true

Optimize routing tables by merging routes, the resulting routing table might route more packets than the original (used only if addStaticRoutes is true)
configurator.updateRoutes bool false

Recalculate static routes if an interface goes down/up or a carrier is lost/back
configurator.dumpTopology bool false

Print extracted network topology to the module output
configurator.dumpLinks bool false

Print recognized network links to the module output
configurator.dumpAddresses bool false

Print assigned IP addresses for all interfaces to the module output
configurator.dumpRoutes bool false

Print configured and optimized routing tables for all nodes to the module output
configurator.dumpConfig string ""

Write configuration into the given config file that can be fed back to speed up subsequent runs (network configurations)
client.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.status.initialStatus string "UP"

TODO @signal, @statistic
client.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.environment.initStage int 0

Initialization stage for the setup command
client.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
client.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
client.environment.setupCommand string ""

A host OS system command
client.environment.teardownCommand string ""

A host OS system command
client.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.pcapRecorder.verbose bool true

Whether to log packets on the module output
client.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
client.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
client.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
client.pcapRecorder.fileFormat string "pcapng"
client.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
client.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
client.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
client.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
client.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
client.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
client.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
client.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
client.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
client.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
client.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
client.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
client.cb.forwardServiceRegistration bool true
client.cb.forwardProtocolRegistration bool true
client.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
client.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
client.bl.forwardServiceRegistration bool true
client.bl.forwardProtocolRegistration bool true
client.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
client.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.li.interfaceTableModule string

Module path to the ~InterfaceTable module
client.li.forwardServiceRegistration bool true
client.li.forwardProtocolRegistration bool true
client.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
client.eth.bitrate double
client.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
client.nl.forwardServiceRegistration bool true
client.nl.forwardProtocolRegistration bool true
client.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
client.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
client.tn.forwardServiceRegistration bool true
client.tn.forwardProtocolRegistration bool true
client.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
client.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
client.at.interfaceTableModule string

Module path to the ~InterfaceTable module
client.at.forwardServiceRegistration bool true
client.at.forwardProtocolRegistration bool true
client.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
client.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
client.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.status.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.status.initialStatus string "UP"

TODO @signal, @statistic
server.environment.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.environment.initStage int 0

Initialization stage for the setup command
server.environment.globalNamespace bool false

Create new network namespaces under /var/run/netns/ (Linux only)
server.environment.namespace string ""

Name of the host OS network namespace (optional) (Linux only)
server.environment.setupCommand string ""

A host OS system command
server.environment.teardownCommand string ""

A host OS system command
server.pcapRecorder.displayStringTextFormat string "rec: %n pks"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.pcapRecorder.verbose bool true

Whether to log packets on the module output
server.pcapRecorder.recordEmptyPackets bool true

Specifies if zero length packets are recorded or not
server.pcapRecorder.enableConvertingPackets bool true

Specifies if converting packets to link type is allowed or not
server.pcapRecorder.pcapFile string ""

The PCAP file to be written, suggested value: pcapFile = "${resultdir}/${configname}-#${runnumber}" + fullpath() + ".pcap"
server.pcapRecorder.fileFormat string "pcapng"
server.pcapRecorder.snaplen int 65535

Maximum number of bytes to record per packet
server.pcapRecorder.timePrecision int 6

Time precision in recorded file. pcap supports only 6 (usec) or 9 (nanosec), pcapng supports more values (see 'if_tsresol' option in pcapng file format).
server.pcapRecorder.dumpBadFrames bool true

Enable dump of frames with hasBitError
server.pcapRecorder.moduleNamePatterns string "wlan[*] eth[*] ppp[*]"

Space-separated list of sibling module names to listen on
server.pcapRecorder.sendingSignalNames string "transmissionEnded"

Space-separated list of outbound packet signals to subscribe to
server.pcapRecorder.receivingSignalNames string "receptionEnded"

Space-separated list of inbound packet signals to subscribe to
server.pcapRecorder.dumpProtocols string "ethernetmac ppp ieee80211mac"

Space-separated list of protocol names as defined in the Protocol class
server.pcapRecorder.packetFilter object "*"

Which packets are considered, matches all packets by default
server.pcapRecorder.helpers string ""

Usable PcapRecorder::IHelper helpers for accept packettype and store/convert packet as specified linktype currently available: "inet::AckingMacToEthernetPcapRecorderHelper"
server.pcapRecorder.alwaysFlush bool false

Flush the pcapFile after each write to ensure that all packets are captured in case of a crash
server.interfaceTable.displayStringTextFormat string ""

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.interfaceTable.displayAddresses bool false

Whether to display IP addresses on links
server.cb.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.cb.interfaceTableModule string

Module path to the ~InterfaceTable module
server.cb.forwardServiceRegistration bool true
server.cb.forwardProtocolRegistration bool true
server.cb.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.cb.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.cb.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.bl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.bl.interfaceTableModule string

Module path to the ~InterfaceTable module
server.bl.forwardServiceRegistration bool true
server.bl.forwardProtocolRegistration bool true
server.bl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.bl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.bl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.li.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.li.interfaceTableModule string

Module path to the ~InterfaceTable module
server.li.forwardServiceRegistration bool true
server.li.forwardProtocolRegistration bool true
server.li.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.li.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.li.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.eth.bitrate double
server.nl.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.nl.interfaceTableModule string

Module path to the ~InterfaceTable module
server.nl.forwardServiceRegistration bool true
server.nl.forwardProtocolRegistration bool true
server.nl.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.nl.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.nl.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.tn.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.tn.interfaceTableModule string

Module path to the ~InterfaceTable module
server.tn.forwardServiceRegistration bool true
server.tn.forwardProtocolRegistration bool true
server.tn.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.tn.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.tn.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default
server.at.displayStringTextFormat string "processed %p pk (%l)"

Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
server.at.interfaceTableModule string

Module path to the ~InterfaceTable module
server.at.forwardServiceRegistration bool true
server.at.forwardProtocolRegistration bool true
server.at.interfaceMapping object {}

Maps network interface names to connected submodule names (e.g. {"eth0": "bridging"}), overrides automatically learned dispatching; * overrides all learned network interfaces, ? overrides default
server.at.serviceMapping object {}

Maps protocols to connected submodule names (e.g. {"ethernetmac": "bridging"}), overrides automatically learned dispatching; * overrides all learned services, ? overrides default
server.at.protocolMapping object {}

Maps protocols to connected submodule names (e.g. {"ipv4": "bridging"}), overrides automatically learned dispatching; * overrides all learned protocols, ? overrides default

Source code

//
// A generated network with grid topology.
//
network Network
{
    submodules:
        R00: MulticastRouter {
            @display("p=400,100");
            gates:
                ethg[4];
        }
        R01: MulticastRouter {
            @display("p=400,190");
            gates:
                ethg[4];
        }
        R02: MulticastRouter {
            @display("p=400,280");
            gates:
                ethg[4];
        }
        R03: MulticastRouter {
            @display("p=400,370");
            gates:
                ethg[4];
        }

        R10: MulticastRouter {
            @display("p=550,100");
            gates:
                ethg[4];
        }
        R11: MulticastRouter {
            @display("p=550,190");
            gates:
                ethg[4];
        }
        R12: MulticastRouter {
            @display("p=550,280");
            gates:
                ethg[4];
        }
        R13: MulticastRouter {
            @display("p=550,370");
            gates:
                ethg[4];
        }

        R20: MulticastRouter {
            @display("p=700,100");
            gates:
                ethg[4];
        }
        R21: MulticastRouter {
            @display("p=700,190");
            gates:
                ethg[4];
        }
        R22: MulticastRouter {
            @display("p=700,280");
            gates:
                ethg[4];
        }
        R23: MulticastRouter {
            @display("p=700,370");
            gates:
                ethg[4];
        }

        R30: MulticastRouter {
            @display("p=850,100");
            gates:
                ethg[4];
        }
        R31: MulticastRouter {
            @display("p=850,190");
            gates:
                ethg[4];
        }
        R32: MulticastRouter {
            @display("p=850,280");
            gates:
                ethg[4];
        }
        R33: MulticastRouter {
            @display("p=850,370");
            gates:
                ethg[4];
        }


        configurator: Ipv4NetworkConfigurator {
            @display("p=100,100;is=s");
        }
        client: StandardHost {
            @display("p=1000,370");
        }
        server: StandardHost {
            @display("p=250,100");
        }
    connections allowunconnected:
        R00.ethg[1] <--> Eth100M <--> R10.ethg[0];
        R00.ethg[3] <--> Eth100M <--> R01.ethg[2];
        R01.ethg[1] <--> Eth100M <--> R11.ethg[0];
        R01.ethg[3] <--> Eth100M <--> R02.ethg[2];
        R02.ethg[1] <--> Eth100M <--> R12.ethg[0];
        R02.ethg[3] <--> Eth100M <--> R03.ethg[2];
        R03.ethg[1] <--> Eth100M <--> R13.ethg[0];

        R10.ethg[1] <--> Eth100M <--> R20.ethg[0];
        R10.ethg[3] <--> Eth100M <--> R11.ethg[2];
        R11.ethg[1] <--> Eth100M <--> R21.ethg[0];
        R11.ethg[3] <--> Eth100M <--> R12.ethg[2];
        R12.ethg[1] <--> Eth100M <--> R22.ethg[0];
        R12.ethg[3] <--> Eth100M <--> R13.ethg[2];
        R13.ethg[1] <--> Eth100M <--> R23.ethg[0];

        R20.ethg[1] <--> Eth100M <--> R30.ethg[0];
        R20.ethg[3] <--> Eth100M <--> R21.ethg[2];
        R21.ethg[1] <--> Eth100M <--> R31.ethg[0];
        R21.ethg[3] <--> Eth100M <--> R22.ethg[2];
        R22.ethg[1] <--> Eth100M <--> R32.ethg[0];
        R22.ethg[3] <--> Eth100M <--> R23.ethg[2];
        R23.ethg[1] <--> Eth100M <--> R33.ethg[0];


        R30.ethg[3] <--> Eth100M <--> R31.ethg[2];

        R31.ethg[3] <--> Eth100M <--> R32.ethg[2];

        R32.ethg[3] <--> Eth100M <--> R33.ethg[2];


        server.ethg++ <--> Eth100M <--> R00.ethg[0];
        R33.ethg[1] <--> Eth100M <--> client.ethg++;
}
File: examples/pim/iptv/Network.ned

This documentation is released under the Creative Commons license