def create_hosts_and_learn(cls, count):
"""
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address. Create
L2 MAC packet stream with host MAC addresses per interface to let
the bridge domain learn these MAC addresses.
:param count: Integer number of hosts to create MAC/IPv4 addresses for.
"""
n_int = len(cls.pg_interfaces)
macs_per_if = count / n_int
i = -1
for pg_if in cls.pg_interfaces:
i += 1
start_nr = macs_per_if * i
end_nr = count if i == (n_int - 1) else macs_per_if * (i + 1)
cls.hosts_by_pg_idx[pg_if.sw_if_index] = []
hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index]
packets = []
for j in range(start_nr, end_nr):
host = Host("00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02x.%u" % (pg_if.sw_if_index, j))
packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac))
hosts.append(host)
if hasattr(pg_if, 'sub_if'):
packet = pg_if.sub_if.add_dot1_layer(packet)
packets.append(packet)
pg_if.add_stream(packets)
cls.logger.info("Sending broadcast eth frames for MAC learning")
cls.pg_start()
def create_hosts(self, count, start=0):
"""
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address.
:param int count: Number of hosts to create MAC/IPv4 addresses for.
:param int start: Number to start numbering from.
"""
n_int = len(self.pg_interfaces)
macs_per_if = count // n_int
i = -1
for pg_if in self.pg_interfaces:
i += 1
start_nr = macs_per_if * i + start
end_nr = (
count + start if i == (n_int - 1) else macs_per_if * (i + 1) + start
)
hosts = self.hosts_by_pg_idx[pg_if.sw_if_index]
for j in range(start_nr, end_nr):
host = Host(
"00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02x.%u" % (pg_if.sw_if_index, j),
"2017:dead:%02x::%u" % (pg_if.sw_if_index, j),
)
hosts.append(host)
def na_resp_host(self, src_host, rx):
self.assertEqual(rx[Ether].dst, src_host.mac)
self.assertEqual(in6_ptop(rx[IPv6].dst), in6_ptop(src_host.ip6))
self.assertTrue(rx.haslayer(ICMPv6ND_NA))
self.assertTrue(rx.haslayer(ICMPv6NDOptDstLLAddr))
na = rx[ICMPv6ND_NA]
return Host(mac=na.lladdr, ip6=na.tgt)
def system_update(request):
_response = {"date":"-", "ipaddress":""}
if request.method == 'GET':
try:
_time = datetime.now()
_host = Host()
_info = _host.getSystemInfo()
_info["wlan0"] = _host.getIPAddress("wlan0")
_info["eth0"] = _host.getIPAddress("eth0")
_response["date"] = _time.strftime("%Y-%m-%d %H:%M:%S")
_response.update(_info)
return Response(_response, status.HTTP_200_OK)
except Exception, e:
print "Exception(system) : ",e
def system_update(request):
_response = {"date": "-", "ipaddress": ""}
if request.method == 'GET':
try:
_time = datetime.now()
_host = Host()
_info = _host.getSystemInfo()
_info["wlan0"] = _host.getIPAddress("wlan0")
_info["eth0"] = _host.getIPAddress("eth0")
_response["date"] = _time.strftime("%Y-%m-%d %H:%M:%S")
_response.update(_info)
return Response(_response, status.HTTP_200_OK)
except Exception, e:
print "Exception(system) : ", e
def arp_resp_host(self, src_host, arp_resp):
ether = arp_resp[Ether]
self.assertEqual(ether.dst, src_host.mac)
arp = arp_resp[ARP]
self.assertEqual(arp.hwtype, 1)
self.assertEqual(arp.ptype, 0x800)
self.assertEqual(arp.hwlen, 6)
self.assertEqual(arp.plen, 4)
arp_opts = {"who-has": 1, "is-at": 2}
self.assertEqual(arp.op, arp_opts["is-at"])
self.assertEqual(arp.hwdst, src_host.mac)
self.assertEqual(arp.pdst, src_host.ip4)
return Host(mac=arp.hwsrc, ip4=arp.psrc)
def create_host_lists(cls, count):
"""
Method to create required number of MAC and IPv4 addresses.
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address too.
:param count: Number of hosts to create MAC and IPv4 addresses for.
"""
for pg_if in cls.pg_interfaces:
cls.hosts_by_pg_idx[pg_if.sw_if_index] = []
hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index]
for j in range(0, count):
host = Host("00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02x.%u" % (pg_if.sw_if_index, j))
hosts.append(host)
def create_hosts(cls, hosts_per_if):
"""
Create required number of host MAC addresses and distribute them
among interfaces. Create host IPv4 address for every host MAC
address.
:param int hosts_per_if: Number of hosts per if to create MAC/IPv4
addresses for.
"""
c = hosts_per_if
assert(not cls.hosts_by_pg_idx)
for i in range(len(cls.pg_interfaces)):
pg_idx = cls.pg_interfaces[i].sw_if_index
cls.hosts_by_pg_idx[pg_idx] = [Host(
"00:00:00:ff:%02x:%02x" % (pg_idx, j + 1),
"172.17.1%02u.%u" % (pg_idx, j + 1)) for j in range(c)]
def create_hosts_and_learn(cls, count):
for pg_if in cls.pg_interfaces:
cls.hosts_by_pg_idx[pg_if.sw_if_index] = []
hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index]
packets = []
for j in range(1, count + 1):
host = Host("00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02x.%u" % (pg_if.sw_if_index, j))
packet = (Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac))
hosts.append(host)
if hasattr(pg_if, 'sub_if'):
packet = pg_if.sub_if.add_dot1_layer(packet)
packets.append(packet)
pg_if.add_stream(packets)
cls.logger.info("Sending broadcast eth frames for MAC learning")
cls.pg_enable_capture(cls.pg_interfaces)
cls.pg_start()
def generate_remote_hosts(self, count=1):
"""Generate and add remote hosts for the interface.
:param int count: Number of generated remote hosts.
"""
self._remote_hosts = []
self._hosts_by_mac = {}
self._hosts_by_ip4 = {}
self._hosts_by_ip6 = {}
for i in range(2, count+2): # 0: network address, 1: local vpp address
mac = "02:%02x:00:00:ff:%02x" % (self.sw_if_index, i)
ip4 = "172.16.%u.%u" % (self.sw_if_index, i)
ip6 = "fd01:%04x::%04x" % (self.sw_if_index, i)
host = Host(mac, ip4, ip6)
self._remote_hosts.append(host)
self._hosts_by_mac[mac] = host
self._hosts_by_ip4[ip4] = host
self._hosts_by_ip6[ip6] = host
def create_host_lists(self, count):
""" Method to create required number of MAC and IPv4 addresses.
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address too.
:param count: Number of hosts to create MAC and IPv4 addresses for.
"""
# mapping between packet-generator index and lists of test hosts
self.hosts_by_pg_idx = dict()
for pg_if in self.pg_interfaces:
# self.MY_MACS[i.sw_if_index] = []
# self.MY_IP4S[i.sw_if_index] = []
self.hosts_by_pg_idx[pg_if.sw_if_index] = []
hosts = self.hosts_by_pg_idx[pg_if.sw_if_index]
for j in range(0, count):
host = Host("00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02x.%u" % (pg_if.sw_if_index, j))
hosts.append(host)
def create_hosts(cls, count):
"""
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address.
:param int count: Number of hosts to create MAC/IPv4 addresses for.
"""
n_int = len(cls.pg_interfaces)
macs_per_if = count / n_int
i = -1
for pg_if in cls.pg_interfaces:
i += 1
start_nr = macs_per_if * i
end_nr = count if i == (n_int - 1) else macs_per_if * (i + 1)
hosts = cls.hosts_by_pg_idx[pg_if.sw_if_index]
for j in range(start_nr, end_nr):
host = Host("00:00:00:ff:%02x:%02x" % (pg_if.sw_if_index, j),
"172.17.1%02u.%u" % (pg_if.sw_if_index, j))
hosts.append(host)
def play_single_game(strategy="random", opts=3):
# Get show-time elements
game = Game.random(number_of_options=opts)
host = Host(manage_game=game)
guest = Guest()
print(game)
# Ask guest to choose a door
first_choice = guest.choose(options=host.show_options(),
strategy=Guest.Strategy.RANDOM)
print("(t=1) Guest's first choice: {}".format(first_choice))
# Host reveals another door
revealed_door = host.reveal(given_guest_choice=first_choice)
print("(t=2) Host reveals door with a goat: {}".format(revealed_door))
# Final guest choice
final_choice = guest.choose(options=host.show_options(),
strategy=strategy)
print("(t=3) Guest's final choice: {}".format(final_choice))
# Host ends game!
result = host.end_game(final_choice=final_choice)
print("(t=4) Game result {}".format(result))
def ip6_host(cls, subnet, host, mac):
return Host(mac=mac, ip6="fd01:%x::%x" % (subnet, host))
def ip4_host(cls, subnet, host, mac):
return Host(mac=mac, ip4="172.17.1%02u.%u" % (subnet, host))
def get_task():
host = Host(get_host())
return Bunch(
host=host,
targets=CONFIGS[host],
)
def nd_event_host(self, e):
return Host(str(e.mac), ip6=str(e.ip))
def arp_event_host(self, e):
return Host(str(e.mac), ip4=str(e.ip))
def h(j): return Host(mac(j), ip(j)) hosts[swif] = [h(j) for j in range(n_hosts_per_if)]
def arp_event_host(self, e):
return Host(mac=':'.join(['%02x' % ord(char) for char in e.new_mac]),
ip4=self.inttoip4(e.address))
def nd_event_host(self, e):
return Host(mac=':'.join(['%02x' % ord(char) for char in e.new_mac]),
ip6=inet_ntop(AF_INET6, e.address))
def h(j):
return Host(mac(j), ip(j))
