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