src/nepi/testbeds/ns3/factories_metadata_v3_9_RC3.py

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