src/nepi/testbeds/ns3/factories_metadata.py

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