src/nepi/testbeds/ns3/factories_metadata_v3_9_RC3.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.util.constants import AF_INET, STATUS_NOT_STARTED, STATUS_RUNNING, \
   5         STATUS_FINISHED, STATUS_UNDETERMINED
   6
   7 from nepi.util.tunchannel_impl import \
   8     preconfigure_tunchannel, postconfigure_tunchannel, \
   9     wait_tunchannel, create_tunchannel
  10
  11
  12 def _get_ipv4_protocol_guid(testbed_instance, node_guid):
  13     # search for the Ipv4L3Protocol asociated with the device
  14     protos_guids = testbed_instance.get_connected(node_guid, "protos", "node")
  15     if len(protos_guids) == 0:
  16         raise RuntimeError("No protocols where found for the node %d" % node_guid)
  17     ipv4_guid = None
  18     for proto_guid in protos_guids:
  19         proto_factory_id = testbed_instance._create[proto_guid]
  20         if proto_factory_id == "ns3::Ipv4L3Protocol":
  21             ipv4_guid = proto_guid
  22             break
  23     if not ipv4_guid:
  24         raise RuntimeError("No Ipv4L3Protocol associated to node %d. \
  25                 can't add Ipv4 addresses" % node_guid)
  26     return ipv4_guid
  27
  28 def _get_node_guid(testbed_instance, guid):
  29     # search for the node asociated with the device
  30     node_guids = testbed_instance.get_connected(guid, "node", "devs")
  31     if len(node_guids) == 0:
  32         raise RuntimeError("Can't instantiate interface %d outside netns \
  33                 node" % guid)
  34     node_guid = node_guids[0]
  35     return node_guid
  36
  37 def _get_dev_number(testbed_instance, guid):
  38     node_guid = _get_node_guid(testbed_instance, guid)
  39     dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
  40     interface_number = 0
  41     for guid_ in dev_guids:
  42         if guid_ == guid:
  43             break
  44         interface_number += 1
  45     return interface_number
  46
  47 ### create traces functions ###
  48
  49 def p2pascii_trace(testbed_instance, guid, trace_id):
  50     node_guid = _get_node_guid(testbed_instance, guid)
  51     interface_number = _get_dev_number(testbed_instance, guid)
  52     element = testbed_instance._elements[guid]
  53     filename = "trace-p2p-node-%d-dev-%d.tr" % (node_guid, interface_number)
  54     testbed_instance.follow_trace(guid, trace_id, filename)
  55     filepath = testbed_instance.trace_filename(guid, trace_id)
  56     helper = testbed_instance.ns3.PointToPointHelper()
  57     asciiHelper = testbed_instance.ns3.AsciiTraceHelper()
  58     stream = asciiHelper.CreateFileStream (filepath)
  59     helper.EnableAscii(stream, element)
  60
  61 def p2ppcap_trace(testbed_instance, guid, trace_id):
  62     node_guid = _get_node_guid(testbed_instance, guid)
  63     interface_number = _get_dev_number(testbed_instance, guid)
  64     element = testbed_instance._elements[guid]
  65     filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  66     testbed_instance.follow_trace(guid, trace_id, filename)
  67     filepath = testbed_instance.trace_filename(guid, trace_id)
  68     helper = testbed_instance.ns3.PointToPointHelper()
  69     helper.EnablePcap(filepath, element, explicitFilename = True)
  70
  71 def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
  72     node_guid = _get_node_guid(testbed_instance, guid)
  73     interface_number = _get_dev_number(testbed_instance, guid)
  74     element = testbed_instance._elements[guid]
  75     filename = "trace-csma-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  76     testbed_instance.follow_trace(guid, trace_id, filename)
  77     filepath = testbed_instance.trace_filename(guid, trace_id)
  78     helper = testbed_instance.ns3.CsmaHelper()
  79     helper.EnablePcap(filepath, element, promiscuous = promisc,
  80             explicitFilename = True)
  81
  82 def csmapcap_trace(testbed_instance, guid, trace_id):
  83     promisc = False
  84     _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
  85
  86 def csmapcap_promisc_trace(testbed_instance, guid, trace_id):
  87     promisc = True
  88     _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
  89
  90 def fdpcap_trace(testbed_instance, guid, trace_id):
  91     node_guid = _get_node_guid(testbed_instance, guid)
  92     interface_number = _get_dev_number(testbed_instance, guid)
  93     element = testbed_instance._elements[guid]
  94     filename = "trace-fd-node-%d-dev-%d.pcap" % (node_guid, interface_number)
  95     testbed_instance.follow_trace(guid, trace_id, filename)
  96     filepath = testbed_instance.trace_filename(guid, trace_id)
  97     helper = testbed_instance.ns3.FileDescriptorHelper()
  98     helper.EnablePcap(filepath, element, explicitFilename = True)
  99
 100 def yanswifipcap_trace(testbed_instance, guid, trace_id):
 101     dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
 102     node_guid = _get_node_guid(testbed_instance, dev_guid)
 103     interface_number = _get_dev_number(testbed_instance, dev_guid)
 104     element = testbed_instance._elements[dev_guid]
 105     filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_guid, interface_number)
 106     testbed_instance.follow_trace(guid, trace_id, filename)
 107     filepath = testbed_instance.trace_filename(guid, trace_id)
 108     helper = testbed_instance.ns3.YansWifiPhyHelper()
 109     helper.EnablePcap(filepath, element, explicitFilename = True)
 110
 111 trace_functions = dict({
 112     "P2PPcapTrace": p2ppcap_trace,
 113     "P2PAsciiTrace": p2pascii_trace,
 114     "CsmaPcapTrace": csmapcap_trace,
 115     "CsmaPcapPromiscTrace": csmapcap_promisc_trace,
 116     "FileDescriptorPcapTrace": fdpcap_trace,
 117     "YansWifiPhyPcapTrace": yanswifipcap_trace
 118     })
 119
 120 ### Creation functions ###
 121
 122 wifi_standards = dict({
 123     "WIFI_PHY_STANDARD_holland": 5,
 124     "WIFI_PHY_STANDARD_80211p_SCH": 7,
 125     "WIFI_PHY_STANDARD_80211_5Mhz": 4,
 126     "WIFI_PHY_UNKNOWN": 8,
 127     "WIFI_PHY_STANDARD_80211_10Mhz": 3,
 128     "WIFI_PHY_STANDARD_80211g": 2,
 129     "WIFI_PHY_STANDARD_80211p_CCH": 6,
 130     "WIFI_PHY_STANDARD_80211a": 0,
 131     "WIFI_PHY_STANDARD_80211b": 1
 132 })
 133
 134 def create_element(testbed_instance, guid):
 135     element_factory = testbed_instance.ns3.ObjectFactory()
 136     factory_id = testbed_instance._create[guid]
 137     element_factory.SetTypeId(factory_id)
 138     construct_parameters = testbed_instance._get_construct_parameters(guid)
 139     for name, value in construct_parameters.iteritems():
 140         ns3_value = testbed_instance._to_ns3_value(guid, name, value)
 141         element_factory.Set(name, ns3_value)
 142     element = element_factory.Create()
 143     testbed_instance._elements[guid] = element
 144
 145 def create_node(testbed_instance, guid):
 146     create_element(testbed_instance, guid)
 147     element = testbed_instance._elements[guid]
 148     element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
 149
 150 def create_wifi_standard_model(testbed_instance, guid):
 151     create_element(testbed_instance, guid)
 152     element = testbed_instance._elements[guid]
 153     parameters = testbed_instance._get_parameters(guid)
 154     if "Standard" in parameters:
 155         standard = parameters["Standard"]
 156         if standard:
 157             element.ConfigureStandard(wifi_standards[standard])
 158
 159 def create_ipv4protocol(testbed_instance, guid):
 160     create_element(testbed_instance, guid)
 161     element = testbed_instance._elements[guid]
 162     list_routing = testbed_instance.ns3.Ipv4ListRouting()
 163     element.SetRoutingProtocol(list_routing)
 164     static_routing = testbed_instance.ns3.Ipv4StaticRouting()
 165     list_routing.AddRoutingProtocol(static_routing, 1)
 166
 167
 168 ### Start/Stop functions ###
 169
 170 def start_application(testbed_instance, guid):
 171     element = testbed_instance.elements[guid]
 172     # BUG: without doing this explicit call it doesn't start!!!
 173     # Shouldn't be enough to set the StartTime?
 174     element.Start()
 175
 176 def stop_application(testbed_instance, guid):
 177     element = testbed_instance.elements[guid]
 178     now = testbed_instance.ns3.Simulator.Now()
 179     element.SetStopTime(now)
 180
 181
 182 ### Status functions ###
 183
 184 def status_application(testbed_instance, guid):
 185     if guid not in testbed_instance.elements.keys():
 186         raise RuntimeError("Can't get status on guid %d" % guid )
 187     now = testbed_instance.ns3.Simulator.Now()
 188     if now.IsZero():
 189         return STATUS_NOT_STARTED
 190     app = testbed_instance.elements[guid]
 191     parameters = testbed_instance._get_parameters(guid)
 192     if "StartTime" in parameters and parameters["StartTime"]:
 193         start_value = parameters["StartTime"]
 194         start_time = testbed_instance.ns3.Time(start_value)
 195         if now.Compare(start_time) < 0:
 196             return STATUS_NOT_RUNNING
 197     if "StopTime" in parameters and parameters["StopTime"]:
 198         stop_value = parameters["StopTime"]
 199         stop_time = testbed_instance.ns3.Time(stop_value)
 200         if now.Compare(stop_time) < 0:
 201             return STATUS_RUNNING
 202         else:
 203             return STATUS_FINISHED
 204     return STATUS_UNDETERMINED
 205
 206 ### Configure functions ###
 207
 208 def configure_traces(testbed_instance, guid):
 209     traces = testbed_instance._get_traces(guid)
 210     for trace_id in traces:
 211         trace_func = trace_functions[trace_id]
 212         trace_func(testbed_instance, guid, trace_id)
 213
 214 def configure_element(testbed_instance, guid):
 215     configure_traces(testbed_instance, guid)
 216
 217 def configure_device(testbed_instance, guid):
 218     configure_traces(testbed_instance, guid)
 219
 220     element = testbed_instance._elements[guid]
 221
 222     parameters = testbed_instance._get_parameters(guid)
 223     if "macAddress" in parameters:
 224         address = parameters["macAddress"]
 225         macaddr = testbed_instance.ns3.Mac48Address(address)
 226     else:
 227         macaddr = testbed_instance.ns3.Mac48Address.Allocate()
 228     element.SetAddress(macaddr)
 229
 230     if not guid in testbed_instance._add_address:
 231         return
 232     # search for the node asociated with the device
 233     node_guid = _get_node_guid(testbed_instance, guid)
 234     node = testbed_instance.elements[node_guid]
 235     # search for the Ipv4L3Protocol asociated with the device
 236     ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, node_guid)
 237     ipv4 = testbed_instance._elements[ipv4_guid]
 238     ns3 = testbed_instance.ns3
 239     # add addresses
 240     addresses = testbed_instance._add_address[guid]
 241     for address in addresses:
 242         (address, netprefix, broadcast) = address
 243         # TODO: missing IPV6 addresses!!
 244         ifindex = ipv4.AddInterface(element)
 245         inaddr = ns3.Ipv4InterfaceAddress(ns3.Ipv4Address(address),
 246                 ns3.Ipv4Mask("/%d" % netprefix))
 247         ipv4.AddAddress(ifindex, inaddr)
 248         ipv4.SetMetric(ifindex, 1)
 249         ipv4.SetUp(ifindex)
 250
 251 def _add_static_route(ns3, static_routing,
 252         address, netprefix, nexthop_address, ifindex):
 253     if netprefix == 0:
 254         # Default route: 0.0.0.0/0
 255         static_routing.SetDefaultRoute(nexthop_address, ifindex)
 256     elif netprefix == 32:
 257         # Host route: x.y.z.w/32
 258         static_routing.AddHostRouteTo(address, nexthop_address, ifindex)
 259     else:
 260         # Network route: x.y.z.w/n
 261         mask = ns3.Ipv4Mask("/%d" % netprefix)
 262         static_routing.AddNetworkRouteTo(address, mask, nexthop_address,
 263                 ifindex)
 264
 265 def _add_static_route_if(ns3, static_routing, address, netprefix, ifindex):
 266     if netprefix == 0:
 267         # Default route: 0.0.0.0/0
 268         static_routing.SetDefaultRoute(ifindex)
 269     elif netprefix == 32:
 270         # Host route: x.y.z.w/32
 271         static_routing.AddHostRouteTo(address, ifindex)
 272     else:
 273         # Network route: x.y.z.w/n
 274         mask = ns3.Ipv4Mask("/%d" % netprefix)
 275         static_routing.AddNetworkRouteTo(address, mask, ifindex)
 276
 277 def configure_node(testbed_instance, guid):
 278     configure_traces(testbed_instance, guid)
 279
 280     element = testbed_instance._elements[guid]
 281     if not guid in testbed_instance._add_route:
 282         return
 283     # search for the Ipv4L3Protocol asociated with the device
 284     ipv4_guid = _get_ipv4_protocol_guid(testbed_instance, guid)
 285     ipv4 = testbed_instance._elements[ipv4_guid]
 286     list_routing = ipv4.GetRoutingProtocol()
 287     (static_routing, priority) = list_routing.GetRoutingProtocol(0)
 288     ns3 = testbed_instance.ns3
 289     routes = testbed_instance._add_route[guid]
 290     for route in routes:
 291         (destination, netprefix, nexthop) = route
 292         address = ns3.Ipv4Address(destination)
 293         if nexthop:
 294             nexthop_address = ns3.Ipv4Address(nexthop)
 295             ifindex = -1
 296             # TODO: HACKISH way of getting the ifindex... improve this
 297             nifaces = ipv4.GetNInterfaces()
 298             for ifidx in range(nifaces):
 299                 iface = ipv4.GetInterface(ifidx)
 300                 naddress = iface.GetNAddresses()
 301                 for addridx in range(naddress):
 302                     ifaddr = iface.GetAddress(addridx)
 303                     ifmask = ifaddr.GetMask()
 304                     ifindex = ipv4.GetInterfaceForPrefix(nexthop_address, ifmask)
 305                     if ifindex == ifidx:
 306                         break
 307             _add_static_route(ns3, static_routing,
 308                 address, netprefix, nexthop_address, ifindex)
 309         else:
 310             mask = ns3.Ipv4Mask("/%d" % netprefix)
 311             ifindex = ipv4.GetInterfaceForPrefix(address, mask)
 312             _add_static_route_if(ns3, static_routing,
 313                 address, netprefix, nexthop_address, ifindex)
 314
 315 factories_info = dict({
 316     "ns3::Ping6": dict({
 317         "category": "Application",
 318         "create_function": create_element,
 319         "configure_function": configure_element,
 320         "help": "",
 321         "connector_types": [],
 322         "stop_function": stop_application,
 323         "start_function": start_application,
 324         "status_function": status_application,
 325         "box_attributes": ["MaxPackets",
 326             "Interval",
 327             "RemoteIpv6",
 328             "LocalIpv6",
 329             "PacketSize",
 330             "StartTime",
 331             "StopTime"],
 332     }),
 333      "ns3::UdpL4Protocol": dict({
 334         "category": "Protocol",
 335         "create_function": create_element,
 336         "configure_function": configure_element,
 337         "help": "",
 338         "connector_types": ["node"],
 339         "box_attributes": ["ProtocolNumber"],
 340     }),
 341      "ns3::RandomDiscPositionAllocator": dict({
 342         "category": "Mobility",
 343         "create_function": create_element,
 344         "configure_function": configure_element,
 345         "help": "",
 346         "connector_types": [],
 347         "box_attributes": ["Theta",
 348             "Rho",
 349             "X",
 350             "Y"],
 351     }),
 352      "ns3::Node": dict({
 353         "category": "Topology",
 354         "create_function": create_node,
 355         "configure_function": configure_node,
 356         "help": "",
 357         "connector_types": ["devs", "apps", "protos", "mobility"],
 358         "allow_routes": True,
 359         "box_attributes": [],
 360     }),
 361      "ns3::GridPositionAllocator": dict({
 362         "category": "Mobility",
 363         "create_function": create_element,
 364         "configure_function": configure_element,
 365         "help": "",
 366         "connector_types": [],
 367         "box_attributes": ["GridWidth",
 368             "MinX",
 369             "MinY",
 370             "DeltaX",
 371             "DeltaY",
 372             "LayoutType"],
 373     }),
 374      "ns3::TapBridge": dict({
 375         "category": "Device",
 376         "create_function": create_element,
 377         "configure_function": configure_element,
 378         "help": "",
 379         "connector_types": [],
 380         "allow_addresses": True,
 381         "box_attributes": ["Mtu",
 382             "DeviceName",
 383             "Gateway",
 384             "IpAddress",
 385             "MacAddress",
 386             "Netmask",
 387             "Start",
 388             "Stop"],
 389     }),
 390      "ns3::FlowMonitor": dict({
 391         "category": "",
 392         "create_function": create_element,
 393         "configure_function": configure_element,
 394         "help": "",
 395         "connector_types": [],
 396         "box_attributes": ["MaxPerHopDelay",
 397             "DelayBinWidth",
 398             "JitterBinWidth",
 399             "PacketSizeBinWidth",
 400             "FlowInterruptionsBinWidth",
 401             "FlowInterruptionsMinTime"],
 402     }),
 403      "ns3::ConstantVelocityMobilityModel": dict({
 404         "category": "Mobility",
 405         "create_function": create_element,
 406         "configure_function": configure_element,
 407         "help": "",
 408         "connector_types": ["node"],
 409         "box_attributes": ["Position",
 410            "Velocity"],
 411     }),
 412      "ns3::V4Ping": dict({
 413         "category": "Application",
 414         "create_function": create_element,
 415         "configure_function": configure_element,
 416         "help": "",
 417         "connector_types": ["node"],
 418         "stop_function": stop_application,
 419         "start_function": start_application,
 420         "status_function": status_application,
 421         "box_attributes": ["Remote",
 422             "Verbose",
 423             "Interval",
 424             "Size",
 425             "StartTime",
 426             "StopTime"],
 427     }),
 428      "ns3::dot11s::PeerLink": dict({
 429         "category": "",
 430         "create_function": create_element,
 431         "configure_function": configure_element,
 432         "help": "",
 433         "connector_types": [],
 434         "box_attributes": ["RetryTimeout",
 435             "HoldingTimeout",
 436             "ConfirmTimeout",
 437             "MaxRetries",
 438             "MaxBeaconLoss",
 439             "MaxPacketFailure"],
 440     }),
 441      "ns3::PointToPointNetDevice": dict({
 442         "category": "Device",
 443         "create_function": create_element,
 444         "configure_function": configure_device,
 445         "help": "",
 446         "connector_types": ["node", "err", "queue", "chan"],
 447         "allow_addresses": True,
 448         "box_attributes": ["Mtu",
 449             "Address",
 450             "DataRate",
 451             "InterframeGap"],
 452         "traces": ["p2ppcap", "p2pascii"]
 453     }),
 454      "ns3::NakagamiPropagationLossModel": dict({
 455         "category": "Loss",
 456         "create_function": create_element,
 457         "configure_function": configure_element,
 458         "help": "",
 459         "connector_types": [],
 460         "box_attributes": ["Distance1",
 461             "Distance2",
 462             "m0",
 463             "m1",
 464             "m2"],
 465     }),
 466      "ns3::AarfWifiManager": dict({
 467         "category": "Manager",
 468         "create_function": create_element,
 469         "configure_function": configure_element,
 470         "help": "",
 471         "connector_types": [],
 472         "box_attributes": ["SuccessK",
 473             "TimerK",
 474             "MaxSuccessThreshold",
 475             "MinTimerThreshold",
 476             "MinSuccessThreshold",
 477             "IsLowLatency",
 478             "MaxSsrc",
 479             "MaxSlrc",
 480             "RtsCtsThreshold",
 481             "FragmentationThreshold",
 482             "NonUnicastMode"],
 483     }),
 484      "ns3::Ipv6OptionJumbogram": dict({
 485         "category": "",
 486         "create_function": create_element,
 487         "configure_function": configure_element,
 488         "help": "",
 489         "connector_types": [],
 490         "box_attributes": ["OptionNumber"],
 491     }),
 492      "ns3::TwoRayGroundPropagationLossModel": dict({
 493         "category": "Loss",
 494         "create_function": create_element,
 495         "configure_function": configure_element,
 496         "help": "",
 497         "connector_types": [],
 498         "box_attributes": ["Lambda",
 499             "SystemLoss",
 500             "MinDistance",
 501             "HeightAboveZ"],
 502     }),
 503      "ns3::OnOffApplication": dict({
 504         "category": "Application",
 505         "create_function": create_element,
 506         "configure_function": configure_element,
 507         "help": "",
 508         "connector_types": ["node"],
 509         "stop_function": stop_application,
 510         "start_function": start_application,
 511         "status_function": status_application,
 512         "box_attributes": ["DataRate",
 513             "PacketSize",
 514             "Remote",
 515             "OnTime",
 516             "OffTime",
 517             "MaxBytes",
 518             "Protocol",
 519             "StartTime",
 520             "StopTime"],
 521     }),
 522      "ns3::AdhocWifiMac": dict({
 523         "category": "Mac",
 524         "create_function": create_element,
 525         "configure_function": configure_element,
 526         "help": "",
 527         "connector_types": [],
 528         "box_attributes": ["CtsTimeout",
 529             "AckTimeout",
 530             "BasicBlockAckTimeout",
 531             "CompressedBlockAckTimeout",
 532             "Sifs",
 533             "EifsNoDifs",
 534             "Slot",
 535             "Pifs",
 536             "MaxPropagationDelay",
 537             "Ssid"],
 538     }),
 539      "ns3::ConstantAccelerationMobilityModel": dict({
 540         "category": "Mobility",
 541         "create_function": create_element,
 542         "configure_function": configure_element,
 543         "help": "",
 544         "connector_types": ["node"],
 545         "box_attributes": ["Position",
 546             "Velocity"],
 547     }),
 548      "ns3::GaussMarkovMobilityModel": dict({
 549         "category": "Mobility",
 550         "create_function": create_element,
 551         "configure_function": configure_element,
 552         "help": "",
 553         "connector_types": [],
 554         "box_attributes": ["Bounds",
 555             "TimeStep",
 556             "Alpha",
 557             "MeanVelocity",
 558             "MeanDirection",
 559             "MeanPitch",
 560             "NormalVelocity",
 561             "NormalDirection",
 562             "NormalPitch",
 563             "Position",
 564             "Velocity"],
 565     }),
 566      "ns3::dot11s::HwmpProtocol": dict({
 567         "category": "Protocol",
 568         "create_function": create_element,
 569         "configure_function": configure_element,
 570         "help": "",
 571         "connector_types": [],
 572         "box_attributes": ["RandomStart",
 573             "MaxQueueSize",
 574             "Dot11MeshHWMPmaxPREQretries",
 575             "Dot11MeshHWMPnetDiameterTraversalTime",
 576             "Dot11MeshHWMPpreqMinInterval",
 577             "Dot11MeshHWMPperrMinInterval",
 578             "Dot11MeshHWMPactiveRootTimeout",
 579             "Dot11MeshHWMPactivePathTimeout",
 580             "Dot11MeshHWMPpathToRootInterval",
 581             "Dot11MeshHWMPrannInterval",
 582             "MaxTtl",
 583             "UnicastPerrThreshold",
 584             "UnicastPreqThreshold",
 585             "UnicastDataThreshold",
 586             "DoFlag",
 587             "RfFlag"],
 588     }),
 589      "ns3::NscTcpL4Protocol": dict({
 590         "category": "Protocol",
 591         "create_function": create_element,
 592         "configure_function": configure_element,
 593         "help": "",
 594         "connector_types": [],
 595         "box_attributes": ["Library",
 596           "ProtocolNumber"],
 597     }),
 598      "ns3::dot11s::AirtimeLinkMetricCalculator": dict({
 599         "category": "",
 600         "create_function": create_element,
 601         "configure_function": configure_element,
 602         "help": "",
 603         "connector_types": [],
 604         "box_attributes": ["Dot11sMeshHeaderLength"],
 605     }),
 606      "ns3::UanMacCw": dict({
 607         "category": "",
 608         "create_function": create_element,
 609         "configure_function": configure_element,
 610         "help": "",
 611         "connector_types": [],
 612         "box_attributes": ["CW",
 613            "SlotTime"],
 614     }),
 615      "ns3::AthstatsWifiTraceSink": dict({
 616         "category": "",
 617         "create_function": create_element,
 618         "configure_function": configure_element,
 619         "help": "",
 620         "connector_types": [],
 621         "box_attributes": ["Interval"],
 622     }),
 623      "ns3::FlameStack": dict({
 624         "category": "",
 625         "create_function": create_element,
 626         "configure_function": configure_element,
 627         "help": "",
 628         "connector_types": [],
 629         "box_attributes": [],
 630     }),
 631      "ns3::UanMacRc": dict({
 632         "category": "",
 633         "create_function": create_element,
 634         "configure_function": configure_element,
 635         "help": "",
 636         "connector_types": [],
 637         "box_attributes": ["RetryRate",
 638             "MaxFrames",
 639             "QueueLimit",
 640             "SIFS",
 641             "NumberOfRates",
 642             "MinRetryRate",
 643             "RetryStep",
 644             "NumberOfRetryRates",
 645             "MaxPropDelay"],
 646     }),
 647      "ns3::WaypointMobilityModel": dict({
 648         "category": "Mobility",
 649         "create_function": create_element,
 650         "configure_function": configure_element,
 651         "help": "",
 652         "connector_types": [],
 653         "box_attributes": ["WaypointsLeft",
 654             "Position",
 655             "Velocity"],
 656     }),
 657      "ns3::FileDescriptorNetDevice": dict({
 658         "category": "Device",
 659         "create_function": create_element,
 660         "configure_function": configure_device,
 661         "help": "Network interface associated to a file descriptor",
 662         "connector_types": ["node", "->fd"],
 663         "allow_addresses": True,
 664         "box_attributes": ["Address",
 665             "LinuxSocketAddress",
 666             "tun_proto", "tun_addr", "tun_port", "tun_key"],
 667         "traces": ["fdpcap"]
 668     }),
 669      "ns3::Nepi::TunChannel": dict({
 670         "category": "Channel",
 671         "create_function": create_tunchannel,
 672         "preconfigure_function": preconfigure_tunchannel,
 673         "configure_function": postconfigure_tunchannel,
 674         "start_function": wait_tunchannel,
 675         "help": "Channel to forward FileDescriptorNetDevice data to "
 676                 "other TAP interfaces supporting the NEPI tunneling protocol.",
 677         "connector_types": ["fd->", "udp", "tcp"],
 678         "allow_addresses": False,
 679         "box_attributes": ["tun_proto", "tun_addr", "tun_port", "tun_key"]
 680     }),
 681      "ns3::CsmaNetDevice": dict({
 682         "category": "Device",
 683         "create_function": create_element,
 684         "configure_function": configure_device,
 685         "help": "CSMA (carrier sense, multiple access) interface",
 686         "connector_types": ["node", "chan", "err", "queue"],
 687         "allow_addresses": True,
 688         "box_attributes": ["Address",
 689             "Mtu",
 690             "SendEnable",
 691             "ReceiveEnable"],
 692         "traces": ["csmapcap", "csmapcap_promisc"]
 693     }),
 694      "ns3::UanPropModelThorp": dict({
 695         "category": "",
 696         "create_function": create_element,
 697         "configure_function": configure_element,
 698         "help": "",
 699         "connector_types": [],
 700         "box_attributes": ["SpreadCoef"],
 701     }),
 702      "ns3::NqstaWifiMac": dict({
 703         "category": "Mac",
 704         "create_function": create_element,
 705         "configure_function": configure_element,
 706         "help": "",
 707         "connector_types": [],
 708         "box_attributes": ["ProbeRequestTimeout",
 709             "AssocRequestTimeout",
 710             "MaxMissedBeacons",
 711             "CtsTimeout",
 712             "AckTimeout",
 713             "BasicBlockAckTimeout",
 714             "CompressedBlockAckTimeout",
 715             "Sifs",
 716             "EifsNoDifs",
 717             "Slot",
 718             "Pifs",
 719             "MaxPropagationDelay",
 720             "Ssid"],
 721     }),
 722      "ns3::Icmpv6L4Protocol": dict({
 723         "category": "Protocol",
 724         "create_function": create_element,
 725         "configure_function": configure_element,
 726         "help": "",
 727         "connector_types": ["node"],
 728         "box_attributes": ["DAD",
 729             "ProtocolNumber"],
 730     }),
 731      "ns3::SimpleNetDevice": dict({
 732         "category": "Device",
 733         "create_function": create_element,
 734         "configure_function": configure_element,
 735         "help": "",
 736         "connector_types": ["node", "chan"],
 737         "allow_addresses": True,
 738         "box_attributes": [],
 739     }),
 740      "ns3::FriisPropagationLossModel": dict({
 741         "category": "Loss",
 742         "create_function": create_element,
 743         "configure_function": configure_element,
 744         "help": "",
 745         "connector_types": [],
 746         "box_attributes": ["Lambda",
 747             "SystemLoss",
 748             "MinDistance"],
 749     }),
 750      "ns3::Ipv6OptionRouterAlert": dict({
 751         "category": "",
 752         "create_function": create_element,
 753         "configure_function": configure_element,
 754         "help": "",
 755         "connector_types": [],
 756         "box_attributes": ["OptionNumber"],
 757     }),
 758      "ns3::UniformDiscPositionAllocator": dict({
 759         "category": "Mobility",
 760         "create_function": create_element,
 761         "configure_function": configure_element,
 762         "help": "",
 763         "connector_types": [],
 764         "box_attributes": ["rho",
 765             "X",
 766             "Y"],
 767     }),
 768      "ns3::RandomBoxPositionAllocator": dict({
 769         "category": "Mobility",
 770         "create_function": create_element,
 771         "configure_function": configure_element,
 772         "help": "",
 773         "connector_types": [],
 774         "box_attributes": ["X",
 775             "Y",
 776             "Z"],
 777     }),
 778      "ns3::Ipv6ExtensionDestination": dict({
 779         "category": "",
 780         "create_function": create_element,
 781         "configure_function": configure_element,
 782         "help": "",
 783         "connector_types": [],
 784         "box_attributes": ["ExtensionNumber"],
 785     }),
 786      "ns3::LoopbackNetDevice": dict({
 787         "category": "Device",
 788         "create_function": create_element,
 789         "configure_function": configure_element,
 790         "help": "",
 791         "connector_types": [],
 792         "box_attributes": [],
 793     }),
 794      "ns3::ConstantSpeedPropagationDelayModel": dict({
 795         "category": "Delay",
 796         "create_function": create_element,
 797         "configure_function": configure_element,
 798         "help": "",
 799         "connector_types": ["chan"],
 800         "box_attributes": ["Speed"],
 801     }),
 802      "ns3::Ipv6ExtensionHopByHop": dict({
 803         "category": "",
 804         "create_function": create_element,
 805         "configure_function": configure_element,
 806         "help": "",
 807         "connector_types": [],
 808         "box_attributes": ["ExtensionNumber"],
 809     }),
 810      "ns3::BridgeChannel": dict({
 811         "category": "Channel",
 812         "create_function": create_element,
 813         "configure_function": configure_element,
 814         "help": "",
 815         "connector_types": [],
 816         "box_attributes": [],
 817     }),
 818      "ns3::Radvd": dict({
 819         "category": "",
 820         "create_function": create_element,
 821         "configure_function": configure_element,
 822         "help": "",
 823         "connector_types": [],
 824         "box_attributes": ["StartTime",
 825             "StopTime"],
 826     }),
 827      "ns3::PacketSocket": dict({
 828         "category": "",
 829         "create_function": create_element,
 830         "configure_function": configure_element,
 831         "help": "",
 832         "connector_types": [],
 833         "box_attributes": ["RcvBufSize"],
 834     }),
 835      "ns3::flame::FlameProtocol": dict({
 836         "category": "Protocol",
 837         "create_function": create_element,
 838         "configure_function": configure_element,
 839         "help": "",
 840         "connector_types": [],
 841         "box_attributes": ["BroadcastInterval",
 842             "MaxCost"],
 843     }),
 844      "ns3::Cost231PropagationLossModel": dict({
 845         "category": "Loss",
 846         "create_function": create_element,
 847         "configure_function": configure_element,
 848         "help": "",
 849         "connector_types": [],
 850         "box_attributes": ["Lambda",
 851             "Frequency",
 852             "BSAntennaHeight",
 853             "SSAntennaHeight",
 854             "MinDistance"],
 855     }),
 856      "ns3::Ipv6ExtensionESP": dict({
 857         "category": "",
 858         "create_function": create_element,
 859         "configure_function": configure_element,
 860         "help": "",
 861         "connector_types": [],
 862         "box_attributes": ["ExtensionNumber"],
 863     }),
 864      "ns3::CaraWifiManager": dict({
 865         "category": "Manager",
 866         "create_function": create_element,
 867         "configure_function": configure_element,
 868         "help": "",
 869         "connector_types": [],
 870         "box_attributes": ["ProbeThreshold",
 871             "FailureThreshold",
 872             "SuccessThreshold",
 873             "Timeout",
 874             "IsLowLatency",
 875             "MaxSsrc",
 876             "MaxSlrc",
 877             "RtsCtsThreshold",
 878             "FragmentationThreshold",
 879             "NonUnicastMode"],
 880
 881     }),
 882      "ns3::RttMeanDeviation": dict({
 883         "category": "",
 884         "create_function": create_element,
 885         "configure_function": configure_element,
 886         "help": "",
 887         "connector_types": [],
 888         "box_attributes": ["Gain",
 889             "MaxMultiplier",
 890             "InitialEstimation",
 891             "MinRTO"],
 892     }),
 893      "ns3::Icmpv4L4Protocol": dict({
 894         "category": "Protocol",
 895         "create_function": create_element,
 896         "configure_function": configure_element,
 897         "help": "",
 898         "connector_types": ["node"],
 899         "box_attributes": ["ProtocolNumber"],
 900     }),
 901      "ns3::WaveformGenerator": dict({
 902         "category": "",
 903         "create_function": create_element,
 904         "configure_function": configure_element,
 905         "help": "",
 906         "connector_types": [],
 907         "box_attributes": ["Period",
 908             "DutyCycle"],
 909     }),
 910      "ns3::YansWifiChannel": dict({
 911         "category": "Channel",
 912         "create_function": create_element,
 913         "configure_function": configure_element,
 914         "help": "",
 915         "connector_types": ["phys", "delay", "loss"],
 916         "box_attributes": [],
 917     }),
 918      "ns3::SimpleChannel": dict({
 919         "category": "Channel",
 920         "create_function": create_element,
 921         "configure_function": configure_element,
 922         "help": "",
 923         "connector_types": ["devs"],
 924         "box_attributes": [],
 925     }),
 926      "ns3::Ipv6ExtensionFragment": dict({
 927         "category": "",
 928         "create_function": create_element,
 929         "configure_function": configure_element,
 930         "help": "",
 931         "connector_types": [],
 932         "box_attributes": ["ExtensionNumber"],
 933     }),
 934      "ns3::Dot11sStack": dict({
 935         "category": "",
 936         "create_function": create_element,
 937         "configure_function": configure_element,
 938         "help": "",
 939         "connector_types": [],
 940         "box_attributes": ["Root"],
 941     }),
 942      "ns3::FriisSpectrumPropagationLossModel": dict({
 943         "category": "Loss",
 944         "create_function": create_element,
 945         "configure_function": configure_element,
 946         "help": "",
 947         "connector_types": [],
 948         "box_attributes": [],
 949     }),
 950      "ns3::RandomRectanglePositionAllocator": dict({
 951         "category": "Mobility",
 952         "create_function": create_element,
 953         "configure_function": configure_element,
 954         "help": "",
 955         "connector_types": [],
 956         "box_attributes": ["X",
 957            "Y"],
 958     }),
 959      "ns3::NqapWifiMac": dict({
 960         "category": "",
 961         "create_function": create_element,
 962         "configure_function": configure_element,
 963         "help": "",
 964         "connector_types": [],
 965         "box_attributes": ["BeaconInterval",
 966             "BeaconGeneration",
 967             "CtsTimeout",
 968             "AckTimeout",
 969             "BasicBlockAckTimeout",
 970             "CompressedBlockAckTimeout",
 971             "Sifs",
 972             "EifsNoDifs",
 973             "Slot",
 974             "Pifs",
 975             "MaxPropagationDelay",
 976             "Ssid"],
 977     }),
 978      "ns3::HierarchicalMobilityModel": dict({
 979         "category": "Mobility",
 980         "create_function": create_element,
 981         "configure_function": configure_element,
 982         "help": "",
 983         "connector_types": ["node"],
 984         "box_attributes": ["Position",
 985             "Velocity"],
 986     }),
 987      "ns3::ThreeLogDistancePropagationLossModel": dict({
 988         "category": "Loss",
 989         "create_function": create_element,
 990         "configure_function": configure_element,
 991         "help": "",
 992         "connector_types": [],
 993         "box_attributes": ["Distance0",
 994             "Distance1",
 995             "Distance2",
 996             "Exponent0",
 997             "Exponent1",
 998             "Exponent2",
 999             "ReferenceLoss"],
1000     }),
1001      "ns3::UanNoiseModelDefault": dict({
1002         "category": "",
1003         "create_function": create_element,
1004         "configure_function": configure_element,
1005         "help": "",
1006         "connector_types": [],
1007         "box_attributes": ["Wind",
1008             "Shipping"],
1009     }),
1010      "ns3::dot11s::HwmpRtable": dict({
1011         "category": "",
1012         "create_function": create_element,
1013         "configure_function": configure_element,
1014         "help": "",
1015         "connector_types": [],
1016         "box_attributes": [],
1017     }),
1018      "ns3::PacketBurst": dict({
1019         "category": "",
1020         "create_function": create_element,
1021         "configure_function": configure_element,
1022         "help": "",
1023         "connector_types": [],
1024         "box_attributes": [],
1025     }),
1026      "ns3::RandomPropagationDelayModel": dict({
1027         "category": "Delay",
1028         "create_function": create_element,
1029         "configure_function": configure_element,
1030         "help": "",
1031         "connector_types": [],
1032         "box_attributes": ["Variable"],
1033     }),
1034      "ns3::ArpL3Protocol": dict({
1035         "category": "Protocol",
1036         "create_function": create_element,
1037         "configure_function": configure_element,
1038         "help": "",
1039         "connector_types": ["node"],
1040         "box_attributes": [],
1041     }),
1042      "ns3::SteadyStateRandomWaypointMobilityModel": dict({
1043         "category": "Mobility",
1044         "create_function": create_element,
1045         "configure_function": configure_element,
1046         "help": "",
1047         "connector_types": [],
1048         "box_attributes": ["MinSpeed",
1049             "MaxSpeed",
1050             "MinPause",
1051             "MaxPause",
1052             "MinX",
1053             "MaxX",
1054             "MinY",
1055             "MaxY",
1056             "Position",
1057             "Velocity"],
1058     }),
1059      "ns3::BaseStationNetDevice": dict({
1060         "category": "Device",
1061         "create_function": create_element,
1062         "configure_function": configure_device,
1063         "help": "",
1064         "connector_types": [],
1065         "allow_addresses": True,
1066         "box_attributes": ["InitialRangInterval",
1067             "DcdInterval",
1068             "UcdInterval",
1069             "IntervalT8",
1070             "RangReqOppSize",
1071             "BwReqOppSize",
1072             "MaxRangCorrectionRetries",
1073             "Mtu",
1074             "RTG",
1075             "TTG"],
1076     }),
1077      "ns3::UdpServer": dict({
1078         "category": "Application",
1079         "create_function": create_element,
1080         "configure_function": configure_element,
1081         "help": "",
1082         "connector_types": [],
1083         "stop_function": stop_application,
1084         "start_function": start_application,
1085         "status_function": status_application,
1086         "box_attributes": ["Port",
1087             "PacketWindowSize",
1088             "StartTime",
1089             "StopTime"],
1090     }),
1091      "ns3::AarfcdWifiManager": dict({
1092         "category": "Manager",
1093         "create_function": create_element,
1094         "configure_function": configure_element,
1095         "help": "",
1096         "connector_types": [],
1097         "box_attributes": ["SuccessK",
1098             "TimerK",
1099             "MaxSuccessThreshold",
1100             "MinTimerThreshold",
1101             "MinSuccessThreshold",
1102             "MinRtsWnd",
1103             "MaxRtsWnd",
1104             "TurnOffRtsAfterRateDecrease",
1105             "TurnOnRtsAfterRateIncrease",
1106             "IsLowLatency",
1107             "MaxSsrc",
1108             "MaxSlrc",
1109             "RtsCtsThreshold",
1110             "FragmentationThreshold",
1111             "NonUnicastMode"],
1112     }),
1113      "ns3::UanTransducerHd": dict({
1114         "category": "",
1115         "create_function": create_element,
1116         "configure_function": configure_element,
1117         "help": "",
1118         "connector_types": [],
1119         "box_attributes": [],
1120     }),
1121      "ns3::LogDistancePropagationLossModel": dict({
1122         "category": "Loss",
1123         "create_function": create_element,
1124         "configure_function": configure_element,
1125         "help": "",
1126         "connector_types": ["prev", "next"],
1127         "box_attributes": ["Exponent",
1128             "ReferenceDistance",
1129             "ReferenceLoss"],
1130     }),
1131      "ns3::EmuNetDevice": dict({
1132         "category": "Device",
1133         "create_function": create_element,
1134         "configure_function": configure_element,
1135         "help": "",
1136         "connector_types": ["node", "queue"],
1137         "box_attributes": ["Mtu",
1138             "Address",
1139             "DeviceName",
1140             "Start",
1141             "Stop",
1142             "RxQueueSize"],
1143     }),
1144      "ns3::Ipv6ExtensionLooseRouting": dict({
1145         "category": "",
1146         "create_function": create_element,
1147         "configure_function": configure_element,
1148         "help": "",
1149         "connector_types": [],
1150         "box_attributes": ["ExtensionNumber"],
1151     }),
1152      "ns3::RandomWaypointMobilityModel": dict({
1153         "category": "Mobility",
1154         "create_function": create_element,
1155         "configure_function": configure_element,
1156         "help": "",
1157         "connector_types": ["node"],
1158         "box_attributes": ["Speed",
1159             "Pause",
1160             "Position",
1161             "Velocity"],
1162     }),
1163      "ns3::RangePropagationLossModel": dict({
1164         "category": "",
1165         "create_function": create_element,
1166         "configure_function": configure_element,
1167         "help": "",
1168         "connector_types": [],
1169         "box_attributes": ["MaxRange"],
1170     }),
1171      "ns3::AlohaNoackNetDevice": dict({
1172         "category": "Device",
1173         "create_function": create_element,
1174         "configure_function": configure_element,
1175         "help": "",
1176         "connector_types": [],
1177         "box_attributes": ["Address",
1178             "Mtu"],
1179     }),
1180      "ns3::MatrixPropagationLossModel": dict({
1181         "category": "Loss",
1182         "create_function": create_element,
1183         "configure_function": configure_element,
1184         "help": "",
1185         "connector_types": [],
1186         "box_attributes": ["DefaultLoss"],
1187     }),
1188      "ns3::WifiNetDevice": dict({
1189         "category": "Device",
1190         "create_function": create_element,
1191         "configure_function": configure_device,
1192         "help": "",
1193         "connector_types": ["node", "mac", "phy", "manager"],
1194         "allow_addresses": True,
1195         "box_attributes": ["Mtu"],
1196     }),
1197      "ns3::CsmaChannel": dict({
1198         "category": "Channel",
1199         "create_function": create_element,
1200         "configure_function": configure_element,
1201         "help": "",
1202         "connector_types": ["devs"],
1203         "box_attributes": ["DataRate",
1204             "Delay"],
1205     }),
1206      "ns3::BridgeNetDevice": dict({
1207         "category": "Device",
1208         "create_function": create_element,
1209         "configure_function": configure_element,
1210         "help": "",
1211         "connector_types": ["node"],
1212         "allow_addresses": True,
1213         "box_attributes": ["Mtu",
1214            "EnableLearning",
1215            "ExpirationTime"],
1216     }),
1217      "ns3::Ipv6ExtensionRouting": dict({
1218         "category": "",
1219         "create_function": create_element,
1220         "configure_function": configure_element,
1221         "help": "",
1222         "connector_types": [],
1223         "box_attributes": ["ExtensionNumber"],
1224     }),
1225      "ns3::QstaWifiMac": dict({
1226         "category": "Mac",
1227         "create_function": create_wifi_standard_model,
1228         "configure_function": configure_element,
1229         "help": "Station Wifi MAC Model",
1230         "connector_types": ["dev"],
1231         "box_attributes": ["ProbeRequestTimeout",
1232             "AssocRequestTimeout",
1233             "MaxMissedBeacons",
1234             "CtsTimeout",
1235             "AckTimeout",
1236             "BasicBlockAckTimeout",
1237             "CompressedBlockAckTimeout",
1238             "Sifs",
1239             "EifsNoDifs",
1240             "Slot",
1241             "Pifs",
1242             "MaxPropagationDelay",
1243             "Ssid",
1244             "Standard"],
1245     }),
1246      "ns3::UdpEchoClient": dict({
1247         "category": "Application",
1248         "create_function": create_element,
1249         "configure_function": configure_element,
1250         "help": "",
1251         "connector_types": ["node"],
1252         "stop_function": stop_application,
1253         "start_function": start_application,
1254         "status_function": status_application,
1255         "box_attributes": ["MaxPackets",
1256             "Interval",
1257             "RemoteAddress",
1258             "RemotePort",
1259             "PacketSize",
1260             "StartTime",
1261             "StopTime"],
1262     }),
1263      "ns3::UdpClient": dict({
1264         "category": "Application",
1265         "create_function": create_element,
1266         "configure_function": configure_element,
1267         "help": "",
1268         "connector_types": [],
1269         "stop_function": stop_application,
1270         "start_function": start_application,
1271         "status_function": status_application,
1272         "box_attributes": ["MaxPackets",
1273             "Interval",
1274             "RemoteAddress",
1275             "RemotePort",
1276             "PacketSize",
1277             "StartTime",
1278             "StopTime"],
1279     }),
1280      "ns3::PointToPointChannel": dict({
1281         "category": "Channel",
1282         "create_function": create_element,
1283         "configure_function": configure_element,
1284         "help": "",
1285         "connector_types": ["dev2"],
1286         "box_attributes": ["Delay"],
1287     }),
1288      "ns3::Ipv6StaticRouting": dict({
1289         "category": "",
1290         "create_function": create_element,
1291         "configure_function": configure_element,
1292         "help": "",
1293         "connector_types": [],
1294         "box_attributes": [],
1295     }),
1296      "ns3::DropTailQueue": dict({
1297         "category": "Device",
1298         "create_function": create_element,
1299         "configure_function": configure_element,
1300         "help": "",
1301         "connector_types": ["dev"],
1302         "box_attributes": ["MaxPackets",
1303            "MaxBytes"],
1304     }),
1305      "ns3::ConstantPositionMobilityModel": dict({
1306         "category": "Mobility",
1307         "create_function": create_element,
1308         "configure_function": configure_element,
1309         "help": "",
1310         "connector_types": ["node"],
1311         "box_attributes": ["Position",
1312             "Velocity"],
1313     }),
1314      "ns3::FixedRssLossModel": dict({
1315         "category": "Loss",
1316         "create_function": create_element,
1317         "configure_function": configure_element,
1318         "help": "",
1319         "connector_types": [],
1320         "box_attributes": ["Rss"],
1321     }),
1322      "ns3::EnergySourceContainer": dict({
1323         "category": "",
1324         "create_function": create_element,
1325         "configure_function": configure_element,
1326         "help": "",
1327         "connector_types": [],
1328         "box_attributes": [],
1329     }),
1330      "ns3::RandomWalk2dMobilityModel": dict({
1331         "category": "Mobility",
1332         "create_function": create_element,
1333         "configure_function": configure_element,
1334         "help": "",
1335         "connector_types": ["node"],
1336         "box_attributes": ["Bounds",
1337             "Time",
1338             "Distance",
1339             "Mode",
1340             "Direction",
1341             "Speed",
1342             "Position",
1343             "Velocity"],
1344     }),
1345      "ns3::ListPositionAllocator": dict({
1346         "category": "",
1347         "create_function": create_element,
1348         "configure_function": configure_element,
1349         "help": "",
1350         "connector_types": [],
1351         "box_attributes": [],
1352     }),
1353      "ns3::dot11s::PeerManagementProtocol": dict({
1354         "category": "Protocol",
1355         "create_function": create_element,
1356         "configure_function": configure_element,
1357         "help": "",
1358         "connector_types": [],
1359         "box_attributes": ["MaxNumberOfPeerLinks",
1360             "MaxBeaconShiftValue",
1361             "EnableBeaconCollisionAvoidance"],
1362     }),
1363      "ns3::MeshPointDevice": dict({
1364         "category": "Device",
1365         "create_function": create_element,
1366         "configure_function": configure_element,
1367         "help": "",
1368         "connector_types": [],
1369         "allow_addresses": True,
1370         "box_attributes": ["Mtu"],
1371     }),
1372      "ns3::BasicEnergySource": dict({
1373         "category": "",
1374         "create_function": create_element,
1375         "configure_function": configure_element,
1376         "help": "",
1377         "connector_types": [],
1378         "box_attributes": ["BasicEnergySourceInitialEnergyJ",
1379             "BasicEnergySupplyVoltageV",
1380             "PeriodicEnergyUpdateInterval"],
1381     }),
1382      "ns3::Ipv6OptionPadn": dict({
1383         "category": "",
1384         "create_function": create_element,
1385         "configure_function": configure_element,
1386         "help": "",
1387         "connector_types": [],
1388         "box_attributes": ["OptionNumber"],
1389     }),
1390      "ns3::QapWifiMac": dict({
1391         "category": "Mac",
1392         "create_function": create_wifi_standard_model,
1393         "configure_function": configure_element,
1394         "help": "Access point Wifi MAC Model",
1395         "connector_types": ["dev"],
1396         "box_attributes": ["BeaconInterval",
1397             "BeaconGeneration",
1398             "CtsTimeout",
1399             "AckTimeout",
1400             "BasicBlockAckTimeout",
1401             "CompressedBlockAckTimeout",
1402             "Sifs",
1403             "EifsNoDifs",
1404             "Slot",
1405             "Pifs",
1406             "MaxPropagationDelay",
1407             "Ssid",
1408             "Standard"],
1409     }),
1410      "ns3::YansErrorRateModel": dict({
1411         "category": "Error",
1412         "create_function": create_element,
1413         "configure_function": configure_element,
1414         "help": "",
1415         "connector_types": [],
1416         "box_attributes": [],
1417     }),
1418      "ns3::WifiMacQueue": dict({
1419         "category": "",
1420         "create_function": create_element,
1421         "configure_function": configure_element,
1422         "help": "",
1423         "connector_types": [],
1424         "box_attributes": ["MaxPacketNumber",
1425            "MaxDelay"],
1426     }),
1427      "ns3::NonCommunicatingNetDevice": dict({
1428         "category": "Device",
1429         "create_function": create_element,
1430         "configure_function": configure_element,
1431         "help": "",
1432         "connector_types": [],
1433         "allow_addresses": True,
1434         "box_attributes": [],
1435     }),
1436      "ns3::RateErrorModel": dict({
1437         "category": "Error",
1438         "create_function": create_element,
1439         "configure_function": configure_element,
1440         "help": "",
1441         "connector_types": [],
1442         "box_attributes": ["ErrorUnit",
1443             "ErrorRate",
1444             "RanVar",
1445             "IsEnabled"],
1446     }),
1447      "ns3::MeshWifiInterfaceMac": dict({
1448         "category": "",
1449         "create_function": create_element,
1450         "configure_function": configure_element,
1451         "help": "",
1452         "connector_types": [],
1453         "box_attributes": ["BeaconInterval",
1454             "RandomStart",
1455             "BeaconGeneration",
1456             "CtsTimeout",
1457             "AckTimeout",
1458             "BasicBlockAckTimeout",
1459             "CompressedBlockAckTimeout",
1460             "Sifs",
1461             "EifsNoDifs",
1462             "Slot",
1463             "Pifs",
1464             "MaxPropagationDelay",
1465             "Ssid"],
1466     }),
1467      "ns3::UanPhyCalcSinrDual": dict({
1468         "category": "",
1469         "create_function": create_element,
1470         "configure_function": configure_element,
1471         "help": "",
1472         "connector_types": [],
1473         "box_attributes": [],
1474     }),
1475      "ns3::Ipv6ExtensionAH": dict({
1476         "category": "",
1477         "create_function": create_element,
1478         "configure_function": configure_element,
1479         "help": "",
1480         "connector_types": [],
1481         "box_attributes": ["ExtensionNumber"],
1482     }),
1483      "ns3::SingleModelSpectrumChannel": dict({
1484         "category": "Channel",
1485         "create_function": create_element,
1486         "configure_function": configure_element,
1487         "help": "",
1488         "connector_types": [],
1489         "box_attributes": [],
1490     }),
1491      "ns3::YansWifiPhy": dict({
1492         "category": "Phy",
1493         "create_function": create_wifi_standard_model,
1494         "configure_function": configure_element,
1495         "help": "",
1496         "connector_types": ["dev", "err", "chan"],
1497         "box_attributes": ["EnergyDetectionThreshold",
1498             "CcaMode1Threshold",
1499             "TxGain",
1500             "RxGain",
1501             "TxPowerLevels",
1502             "TxPowerEnd",
1503             "TxPowerStart",
1504             "RxNoiseFigure",
1505             "ChannelSwitchDelay",
1506             "ChannelNumber",
1507             "Standard"],
1508         "traces": ["yanswifipcap"]
1509     }),
1510      "ns3::WifiRadioEnergyModel": dict({
1511         "category": "",
1512         "create_function": create_element,
1513         "configure_function": configure_element,
1514         "help": "",
1515         "connector_types": [],
1516         "box_attributes": ["TxCurrentA",
1517             "RxCurrentA",
1518             "IdleCurrentA",
1519             "SleepCurrentA"],
1520     }),
1521      "ns3::EdcaTxopN": dict({
1522         "category": "",
1523         "create_function": create_element,
1524         "configure_function": configure_element,
1525         "help": "",
1526         "connector_types": [],
1527         "box_attributes": ["BlockAckThreshold",
1528             "MinCw",
1529             "MaxCw",
1530             "Aifsn"],
1531     }),
1532      "ns3::UanPhyPerGenDefault": dict({
1533         "category": "",
1534         "create_function": create_element,
1535         "configure_function": configure_element,
1536         "help": "",
1537         "connector_types": [],
1538         "box_attributes": ["Threshold"],
1539     }),
1540      "ns3::IdealWifiManager": dict({
1541         "category": "Manager",
1542         "create_function": create_element,
1543         "configure_function": configure_element,
1544         "help": "",
1545         "connector_types": [],
1546         "box_attributes": ["BerThreshold",
1547             "IsLowLatency",
1548             "MaxSsrc",
1549             "MaxSlrc",
1550             "RtsCtsThreshold",
1551             "FragmentationThreshold",
1552             "NonUnicastMode"],
1553     }),
1554      "ns3::MultiModelSpectrumChannel": dict({
1555         "category": "Channel",
1556         "create_function": create_element,
1557         "configure_function": configure_element,
1558         "help": "",
1559         "connector_types": [],
1560         "box_attributes": [],
1561     }),
1562      "ns3::HalfDuplexIdealPhy": dict({
1563         "category": "Phy",
1564         "create_function": create_element,
1565         "configure_function": configure_element,
1566         "help": "",
1567         "connector_types": [],
1568         "box_attributes": ["Rate"],
1569     }),
1570      "ns3::UanPhyCalcSinrDefault": dict({
1571         "category": "Phy",
1572         "create_function": create_element,
1573         "configure_function": configure_element,
1574         "help": "",
1575         "connector_types": [],
1576         "box_attributes": [],
1577     }),
1578      "ns3::ReceiveListErrorModel": dict({
1579         "category": "Error",
1580         "create_function": create_element,
1581         "configure_function": configure_element,
1582         "help": "",
1583         "connector_types": [],
1584         "box_attributes": ["IsEnabled"],
1585     }),
1586      "ns3::SpectrumAnalyzer": dict({
1587         "category": "",
1588         "create_function": create_element,
1589         "configure_function": configure_element,
1590         "help": "",
1591         "connector_types": [],
1592         "box_attributes": ["Resolution",
1593         "NoisePowerSpectralDensity"],
1594     }),
1595      "ns3::ConstantRateWifiManager": dict({
1596         "category": "Manager",
1597         "create_function": create_element,
1598         "configure_function": configure_element,
1599         "help": "",
1600         "connector_types": ["dev"],
1601         "box_attributes": ["DataMode",
1602             "ControlMode",
1603             "IsLowLatency",
1604             "MaxSsrc",
1605             "MaxSlrc",
1606             "RtsCtsThreshold",
1607             "FragmentationThreshold",
1608             "NonUnicastMode"],
1609     }),
1610      "ns3::Ipv6OptionPad1": dict({
1611         "category": "",
1612         "create_function": create_element,
1613         "configure_function": configure_element,
1614         "help": "",
1615         "connector_types": [],
1616         "box_attributes": ["OptionNumber"],
1617     }),
1618      "ns3::UdpTraceClient": dict({
1619         "category": "",
1620         "create_function": create_element,
1621         "configure_function": configure_element,
1622         "help": "",
1623         "connector_types": [],
1624         "box_attributes": ["RemoteAddress",
1625             "RemotePort",
1626             "MaxPacketSize",
1627             "StartTime",
1628             "StopTime"],
1629     }),
1630      "ns3::RraaWifiManager": dict({
1631         "category": "Manager",
1632         "create_function": create_element,
1633         "configure_function": configure_element,
1634         "help": "",
1635         "connector_types": [],
1636         "box_attributes": ["Basic",
1637             "Timeout",
1638             "ewndFor54mbps",
1639             "ewndFor48mbps",
1640             "ewndFor36mbps",
1641             "ewndFor24mbps",
1642             "ewndFor18mbps",
1643             "ewndFor12mbps",
1644             "ewndFor9mbps",
1645             "ewndFor6mbps",
1646             "poriFor48mbps",
1647             "poriFor36mbps",
1648             "poriFor24mbps",
1649             "poriFor18mbps",
1650             "poriFor12mbps",
1651             "poriFor9mbps",
1652             "poriFor6mbps",
1653             "pmtlFor54mbps",
1654             "pmtlFor48mbps",
1655             "pmtlFor36mbps",
1656             "pmtlFor24mbps",
1657             "pmtlFor18mbps",
1658             "pmtlFor12mbps",
1659             "pmtlFor9mbps",
1660             "IsLowLatency",
1661             "MaxSsrc",
1662             "MaxSlrc",
1663             "RtsCtsThreshold",
1664             "FragmentationThreshold",
1665             "NonUnicastMode"],
1666     }),
1667      "ns3::RandomPropagationLossModel": dict({
1668         "category": "Loss",
1669         "create_function": create_element,
1670         "configure_function": configure_element,
1671         "help": "",
1672         "connector_types": [],
1673         "box_attributes": ["Variable"],
1674     }),
1675      "ns3::UanChannel": dict({
1676         "category": "Channel",
1677         "create_function": create_element,
1678         "configure_function": configure_element,
1679         "help": "",
1680         "connector_types": [],
1681         "box_attributes": [],
1682     }),
1683      "ns3::MinstrelWifiManager": dict({
1684         "category": "Manager",
1685         "create_function": create_element,
1686         "configure_function": configure_element,
1687         "help": "",
1688         "connector_types": [],
1689         "box_attributes": ["UpdateStatistics",
1690             "LookAroundRate",
1691             "EWMA",
1692             "SegmentSize",
1693             "SampleColumn",
1694             "PacketLength",
1695             "IsLowLatency",
1696             "MaxSsrc",
1697             "MaxSlrc",
1698             "RtsCtsThreshold",
1699             "FragmentationThreshold",
1700             "NonUnicastMode"],
1701     }),
1702      "ns3::UanPhyDual": dict({
1703         "category": "Phy",
1704         "create_function": create_element,
1705         "configure_function": configure_element,
1706         "help": "",
1707         "connector_types": [],
1708         "box_attributes": ["CcaThresholdPhy1",
1709             "CcaThresholdPhy2",
1710             "TxPowerPhy1",
1711             "TxPowerPhy2",
1712             "RxGainPhy1",
1713             "RxGainPhy2",
1714             "SupportedModesPhy1",
1715             "SupportedModesPhy2"],
1716     }),
1717      "ns3::ListErrorModel": dict({
1718         "category": "Error",
1719         "create_function": create_element,
1720         "configure_function": configure_element,
1721         "help": "",
1722         "connector_types": ["dev"],
1723         "box_attributes": ["IsEnabled"],
1724     }),
1725      "ns3::VirtualNetDevice": dict({
1726         "category": "Device",
1727         "create_function": create_element,
1728         "configure_function": configure_element,
1729         "help": "",
1730         "connector_types": [],
1731         "allow_addresses": True,
1732         "box_attributes": ["Mtu"],
1733     }),
1734      "ns3::UanPhyGen": dict({
1735         "category": "Phy",
1736         "create_function": create_element,
1737         "configure_function": configure_element,
1738         "help": "",
1739         "connector_types": [],
1740         "box_attributes": ["CcaThreshold",
1741             "RxThreshold",
1742             "TxPower",
1743             "RxGain",
1744             "SupportedModes"],
1745     }),
1746      "ns3::Ipv6L3Protocol": dict({
1747         "category": "Protocol",
1748         "create_function": create_element,
1749         "configure_function": configure_element,
1750         "help": "",
1751         "connector_types": ["node"],
1752         "box_attributes": ["DefaultTtl",
1753             "IpForward"],
1754     }),
1755      "ns3::PointToPointRemoteChannel": dict({
1756         "category": "Channel",
1757         "create_function": create_element,
1758         "configure_function": configure_element,
1759         "help": "",
1760         "connector_types": [],
1761         "box_attributes": ["Delay"],
1762     }),
1763      "ns3::UanPhyPerUmodem": dict({
1764         "category": "Phy",
1765         "create_function": create_element,
1766         "configure_function": configure_element,
1767         "help": "",
1768         "connector_types": [],
1769         "box_attributes": [],
1770     }),
1771      "ns3::OnoeWifiManager": dict({
1772         "category": "Manager",
1773         "create_function": create_element,
1774         "configure_function": configure_element,
1775         "help": "",
1776         "connector_types": [],
1777         "box_attributes": ["UpdatePeriod",
1778             "RaiseThreshold",
1779             "AddCreditThreshold",
1780             "IsLowLatency",
1781             "MaxSsrc",
1782             "MaxSlrc",
1783             "RtsCtsThreshold",
1784             "FragmentationThreshold",
1785             "NonUnicastMode"],
1786     }),
1787      "ns3::QadhocWifiMac": dict({
1788         "category": "Mac",
1789         "create_function": create_element,
1790         "configure_function": configure_element,
1791         "help": "",
1792         "connector_types": [],
1793         "box_attributes": ["CtsTimeout",
1794             "AckTimeout",
1795             "BasicBlockAckTimeout",
1796             "CompressedBlockAckTimeout",
1797             "Sifs",
1798             "EifsNoDifs",
1799             "Slot",
1800             "Pifs",
1801             "MaxPropagationDelay",
1802             "Ssid"],
1803     }),
1804      "ns3::JakesPropagationLossModel": dict({
1805         "category": "Loss",
1806         "create_function": create_element,
1807         "configure_function": configure_element,
1808         "help": "",
1809         "connector_types": [],
1810         "box_attributes": ["NumberOfRaysPerPath",
1811             "NumberOfOscillatorsPerRay",
1812             "DopplerFreq",
1813             "Distribution"],
1814     }),
1815      "ns3::PacketSink": dict({
1816         "category": "Application",
1817         "create_function": create_element,
1818         "configure_function": configure_element,
1819         "help": "",
1820         "connector_types": ["node"],
1821         "stop_function": stop_application,
1822         "start_function": start_application,
1823         "status_function": status_application,
1824         "box_attributes": ["Local",
1825             "Protocol",
1826             "StartTime",
1827             "StopTime"],
1828     }),
1829      "ns3::RandomDirection2dMobilityModel": dict({
1830         "category": "Mobility",
1831         "create_function": create_element,
1832         "configure_function": configure_element,
1833         "help": "",
1834         "connector_types": ["node"],
1835         "box_attributes": ["Bounds",
1836             "RndSpeed",
1837             "Pause",
1838             "Position",
1839             "Velocity"],
1840     }),
1841      "ns3::UanMacAloha": dict({
1842         "category": "",
1843         "create_function": create_element,
1844         "configure_function": configure_element,
1845         "help": "",
1846         "connector_types": [],
1847         "box_attributes": [],
1848     }),
1849      "ns3::MsduStandardAggregator": dict({
1850         "category": "",
1851         "create_function": create_element,
1852         "configure_function": configure_element,
1853         "help": "",
1854         "connector_types": [],
1855         "box_attributes": ["MaxAmsduSize"],
1856     }),
1857      "ns3::DcaTxop": dict({
1858         "category": "",
1859         "create_function": create_element,
1860         "configure_function": configure_element,
1861         "help": "",
1862         "connector_types": [],
1863         "box_attributes": ["MinCw",
1864             "MaxCw",
1865             "Aifsn"],
1866     }),
1867      "ns3::UanPhyCalcSinrFhFsk": dict({
1868         "category": "Phy",
1869         "create_function": create_element,
1870         "configure_function": configure_element,
1871         "help": "",
1872         "connector_types": [],
1873         "box_attributes": ["NumberOfHops"],
1874     }),
1875      "ns3::UanPropModelIdeal": dict({
1876         "category": "",
1877         "create_function": create_element,
1878         "configure_function": configure_element,
1879         "help": "",
1880         "connector_types": [],
1881         "box_attributes": [],
1882     }),
1883      "ns3::UanMacRcGw": dict({
1884         "category": "",
1885         "create_function": create_element,
1886         "configure_function": configure_element,
1887         "help": "",
1888         "connector_types": [],
1889         "box_attributes": ["MaxReservations",
1890             "NumberOfRates",
1891             "RetryRate",
1892             "MaxPropDelay",
1893             "SIFS",
1894             "NumberOfNodes",
1895             "MinRetryRate",
1896             "RetryStep",
1897             "NumberOfRetryRates",
1898             "TotalRate",
1899             "RateStep",
1900             "FrameSize"],
1901     }),
1902      "ns3::NistErrorRateModel": dict({
1903         "category": "Error",
1904         "create_function": create_element,
1905         "configure_function": configure_element,
1906         "help": "",
1907         "connector_types": ["phy"],
1908         "box_attributes": [],
1909     }),
1910      "ns3::Ipv4L3Protocol": dict({
1911         "category": "Protocol",
1912         "create_function": create_ipv4protocol,
1913         "configure_function": configure_element,
1914         "help": "",
1915         "connector_types": ["node"],
1916         "box_attributes": ["DefaultTtl",
1917             "IpForward",
1918             "WeakEsModel"],
1919     }),
1920      "ns3::aodv::RoutingProtocol": dict({
1921         "category": "Protocol",
1922         "create_function": create_element,
1923         "configure_function": configure_element,
1924         "help": "",
1925         "connector_types": [],
1926         "box_attributes": ["HelloInterval",
1927             "RreqRetries",
1928             "RreqRateLimit",
1929             "NodeTraversalTime",
1930             "NextHopWait",
1931             "ActiveRouteTimeout",
1932             "MyRouteTimeout",
1933             "BlackListTimeout",
1934             "DeletePeriod",
1935             "TimeoutBuffer",
1936             "NetDiameter",
1937             "NetTraversalTime",
1938             "PathDiscoveryTime",
1939             "MaxQueueLen",
1940             "MaxQueueTime",
1941             "AllowedHelloLoss",
1942             "GratuitousReply",
1943             "DestinationOnly",
1944             "EnableHello",
1945             "EnableBroadcast"],
1946     }),
1947      "ns3::TcpL4Protocol": dict({
1948         "category": "Protocol",
1949         "create_function": create_element,
1950         "configure_function": configure_element,
1951         "help": "",
1952         "connector_types": ["node"],
1953         "box_attributes": ["RttEstimatorFactory",
1954             "ProtocolNumber"],
1955     }),
1956      "ns3::olsr::RoutingProtocol": dict({
1957         "category": "Protocol",
1958         "create_function": create_element,
1959         "configure_function": configure_element,
1960         "help": "",
1961         "connector_types": [],
1962         "box_attributes": ["HelloInterval",
1963             "TcInterval",
1964             "MidInterval",
1965             "HnaInterval",
1966             "Willingness"],
1967     }),
1968      "ns3::UdpEchoServer": dict({
1969         "category": "Application",
1970         "create_function": create_element,
1971         "configure_function": configure_element,
1972         "help": "",
1973         "connector_types": ["node"],
1974         "stop_function": stop_application,
1975         "start_function": start_application,
1976         "status_function": status_application,
1977         "box_attributes": ["Port",
1978            "StartTime",
1979            "StopTime"],
1980     }),
1981      "ns3::AmrrWifiManager": dict({
1982         "category": "Manager",
1983         "create_function": create_element,
1984         "configure_function": configure_element,
1985         "help": "",
1986         "connector_types": [],
1987         "box_attributes": ["UpdatePeriod",
1988             "FailureRatio",
1989             "SuccessRatio",
1990             "MaxSuccessThreshold",
1991             "MinSuccessThreshold",
1992             "IsLowLatency",
1993             "MaxSsrc",
1994             "MaxSlrc",
1995             "RtsCtsThreshold",
1996             "FragmentationThreshold",
1997             "NonUnicastMode"],
1998     }),
1999      "ns3::ArfWifiManager": dict({
2000         "category": "Manager",
2001         "create_function": create_element,
2002         "configure_function": configure_element,
2003         "help": "",
2004         "connector_types": ["dev"],
2005         "box_attributes": ["TimerThreshold",
2006             "SuccessThreshold",
2007             "IsLowLatency",
2008             "MaxSsrc",
2009             "MaxSlrc",
2010             "RtsCtsThreshold",
2011             "FragmentationThreshold",
2012             "NonUnicastMode"],
2013     }),
2014      "ns3::SubscriberStationNetDevice": dict({
2015         "category": "Device",
2016         "create_function": create_element,
2017         "configure_function": configure_element,
2018         "help": "",
2019         "connector_types": [],
2020         "allow_addresses": True,
2021         "box_attributes": ["LostDlMapInterval",
2022             "LostUlMapInterval",
2023             "MaxDcdInterval",
2024             "MaxUcdInterval",
2025             "IntervalT1",
2026             "IntervalT2",
2027             "IntervalT3",
2028             "IntervalT7",
2029             "IntervalT12",
2030             "IntervalT20",
2031             "IntervalT21",
2032             "MaxContentionRangingRetries",
2033             "Mtu",
2034             "RTG",
2035             "TTG"],
2036     }),
2037      "ns3::flame::FlameRtable": dict({
2038         "category": "",
2039         "create_function": create_element,
2040         "configure_function": configure_element,
2041         "help": "",
2042         "connector_types": [],
2043         "box_attributes": ["Lifetime"],
2044     }),
2045 })