+ def add_ns_fdnd(self, ns, node):
+ fdnd = ns.create("ns3::FdNetDevice")
+ node.connector("devs").connect(fdnd.connector("node"))
+ #fdnd.enable_trace("FdPcapTrace")
+ return fdnd
+
+ def add_ns_node(self, ns):
+ node = ns.create("ns3::Node")
+ ipv4 = ns.create("ns3::Ipv4L3Protocol")
+ arp = ns.create("ns3::ArpL3Protocol")
+ icmp = ns.create("ns3::Icmpv4L4Protocol")
+ udp = ns.create("ns3::UdpL4Protocol")
+ node.connector("protos").connect(ipv4.connector("node"))
+ node.connector("protos").connect(arp.connector("node"))
+ node.connector("protos").connect(icmp.connector("node"))
+ node.connector("protos").connect(udp.connector("node"))
+ return node
+
+ def add_ns_wifi_dev(self, ns, node, access_point = False):
+ wifi = ns.create("ns3::WifiNetDevice")
+ node.connector("devs").connect(wifi.connector("node"))
+
+ phy = ns.create("ns3::YansWifiPhy")
+ error = ns.create("ns3::NistErrorRateModel")
+ manager = ns.create("ns3::ArfWifiManager")
+ if access_point:
+ mac = ns.create("ns3::ApWifiMac")
+ else:
+ mac = ns.create("ns3::StaWifiMac")
+
+ phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
+ mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
+ phy.connector("err").connect(error.connector("phy"))
+ wifi.connector("phy").connect(phy.connector("dev"))
+ wifi.connector("mac").connect(mac.connector("dev"))
+ wifi.connector("manager").connect(manager.connector("dev"))
+
+ #phy.enable_trace("YansWifiPhyPcapTrace")
+ return wifi, phy
+
+ def add_ns_constant_mobility(self, ns, node, x, y, z):
+ mobility = ns.create("ns3::ConstantPositionMobilityModel")
+ position = "%d:%d:%d" % (x, y, z)
+ mobility.set_attribute_value("Position", position)
+ node.connector("mobility").connect(mobility.connector("node"))
+ return mobility
+
+ def add_ns_wifi_channel(self, ns):
+ channel = ns.create("ns3::YansWifiChannel")
+ delay = ns.create("ns3::ConstantSpeedPropagationDelayModel")
+ loss = ns.create("ns3::LogDistancePropagationLossModel")
+ channel.connector("delay").connect(delay.connector("chan"))
+ channel.connector("loss").connect(loss.connector("prev"))
+ return channel
+
+ def make_ns_wifi(self, ns, pl, pl_ns_root, inet, numwifinodes, nextip):
+ base=struct.unpack('!L',socket.inet_aton(self.vnet))[0]
+ error = False
+ for i in xrange(2, 6):
+ nr = int(math.pow(2, i))
+ if nr <= (numwifinodes + 2):
+ break
+ else:
+ error = True
+
+ # how many IPs will we need?
+ # 1 for the AP, 2 for each station and one for each extra PL node
+ # BUT we need to also reserve IPs to sum up to a posible subnetwork
+ # number of nodes: 2, 4, 8, 16, etc ...
+ # And finally, we need 2 extra IPs for the PL-AP iface
+
+ nrips = (1 + 2*numwifinodes + nr + 2)
+ if nrips + nextip[0] > 255:
+ error = True
+ if error:
+ raise RuntimeError("There are not enough IP addresses for the wireless network", )
+
+ netprefix = 32 - i
+ _nextwifiip = [254]
+ def nextwifiip():
+ ip = socket.inet_ntoa(struct.pack('!L',(base | _nextwifiip[0])))
+ _nextwifiip[0] -= 1
+ return ip
+
+ _nextnstapip = [(254 - nr -1)]
+ def nextnstapip():
+ ip = socket.inet_ntoa(struct.pack('!L',(base | _nextnstapip[0])))
+ _nextnstapip[0] -= 1
+ return ip
+
+ _nexttapip = [(254 - nr - 1 - numwifinodes)]
+ def nexttapip():
+ ip = socket.inet_ntoa(struct.pack('!L',(base | _nexttapip[0])))
+ _nexttapip[0] -= 1
+ return ip
+
+ # WIFI network
+ wifi_chan = self.add_ns_wifi_channel(ns)
+
+ # AP node
+ ap_node = self.add_ns_node(ns)
+ self.add_ns_constant_mobility(ns, ap_node, 0, 0, 0)
+ ap_wifi, ap_phy = self.add_ns_wifi_dev(ns, ap_node, access_point = True)
+ ap_phy.connector("chan").connect(wifi_chan.connector("phys"))
+
+ # connect AP to PL
+ _nextplip = (254 - nrips)
+ pl_ip = socket.inet_ntoa(struct.pack('!L',(base | _nextplip)))
+ print "PL IP %s" % pl_ip
+ _nextplip -= 1
+ ns_ip = socket.inet_ntoa(struct.pack('!L',(base | _nextplip)))
+ print "NS IP %s" % ns_ip
+ self.add_pl_ns_connection(pl, pl_ns_root, pl_ip, ns, ap_node, ns_ip)
+
+ # routes in and out ns
+ self.add_route(ap_node, self.vnet, 24, pl_ip)
+ net = 256 - nr
+ ip = socket.inet_ntoa(struct.pack('!L',(base | net)))
+ self.add_route(pl_ns_root, ip, netprefix, ns_ip)
+
+ ap_ip = nextwifiip()
+ print "AP IP %s" % ap_ip
+ self.add_ip_address(ap_wifi, ap_ip, netprefix)
+
+ r = 50
+ # STA nodes
+ for i in xrange(0, numwifinodes):
+ stai = self.add_ns_node(ns)
+ angi = (360/numwifinodes)*i
+ xi = r*math.cos(angi)
+ yi = r*math.sin(angi)
+ self.add_ns_constant_mobility(ns, stai, xi, yi, 0)
+ wifi, phy = self.add_ns_wifi_dev(ns, stai, access_point = False)
+ phy.connector("chan").connect(wifi_chan.connector("phys"))
+
+ wifi_ip = nextwifiip()
+ print "WIFI IP %s" % wifi_ip
+ self.add_ip_address(wifi, wifi_ip, netprefix)
+ self.add_route(stai, self.vnet, 24, ap_ip)
+
+ """
+ pl_nodei, pl_ifacei = self.add_pl_ns_node(pl, inet,
+ "node2%d_pl"%i)
+
+ pl_addr = (self.base_addr%(net+1))
+ ns3_addr = (self.base_addr%(net+2))
+ self.add_pl_ns_tunchan_connection(pl_desc, pl_nodei, pl_addr,
+ ns, stai, ns3_addr)
+ self.add_route(pl_nodei, (self.base_addr%32), 27, ns3_addr)
+ self.add_route(pl_nodei, (self.base_addr%0), 30, ns3_addr)
+ self.add_route(pl_nodei, (self.base_addr%4), 30, ns3_addr)
+
+ network = (self.base_addr%net)
+ self.add_route(netns_node, network, 30, (self.base_addr%2))
+ self.add_route(pl_node1, network, 30, (self.base_addr%6))
+ self.add_route(ap_node, network, 30, wifi_addr)
+ """
+
+ def make_pl_overlay(self, numnodes, numwifinodes):
+ print "make_pl_overlay ..."