src/nepi/testbeds/ns3/factories_metadata_v3_9.py

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