def test_to_string(self):
option_values = ['tag', 'length', 'value']
opt_str_list = []
for option in self.option_list:
_opt_str = ','.join(['%s=%s' % (k, repr(getattr(option, k)))
for k, v in inspect.getmembers(option)
if k in option_values])
opt_str = '%s(%s)' % (dhcp.option.__name__, _opt_str)
opt_str_list.append(opt_str)
option_str = '[%s]' % ', '.join(opt_str_list)
opts_vals = {'magic_cookie': repr(socket.inet_ntoa(self.magic_cookie)),
'option_list': option_str,
'options_len': repr(self.options.options_len)}
_options_str = ','.join(['%s=%s' % (k, opts_vals[k])
for k, v in inspect.getmembers(self.options)
if k in opts_vals])
options_str = '%s(%s)' % (dhcp.options.__name__, _options_str)
dhcp_values = {'op': repr(self.op),
'htype': repr(self.htype),
'hlen': repr(self.hlen),
'hops': repr(self.hops),
'xid': repr('0x%x' % self.xid),
'secs': repr(self.secs),
'flags': repr(self.flags),
'ciaddr': repr(ip.ipv4_to_str(self.ciaddr)),
'yiaddr': repr(ip.ipv4_to_str(self.yiaddr)),
'siaddr': repr(ip.ipv4_to_str(self.siaddr)),
'giaddr': repr(ip.ipv4_to_str(self.giaddr)),
'chaddr': repr(mac.haddr_to_str(self.chaddr)),
'sname': repr(self.sname),
'boot_file': repr(self.boot_file),
'options': options_str}
_dh_str = ','.join(['%s=%s' % (k, dhcp_values[k])
for k, v in inspect.getmembers(self.dh)
if k in dhcp_values])
dh_str = '%s(%s)' % (dhcp.dhcp.__name__, _dh_str)
eq_(str(self.dh), dh_str)
eq_(repr(self.dh), dh_str)
def update(self, domain_id, hosts):
for host in hosts:
if host.state == OXPP_ACTIVE:
self.hosts.add(host)
self.locations[domain_id].add(ipv4_to_str(host.ip))
self.ip_host.setdefault(host.ip, None)
self.ip_host[host.ip] = host
else:
if host.ip in self.locations[domain_id]:
self.locations[domain_id].remove(host.ip)
self.hosts.remove(hosts)
del self.ip_host[host.ip]
def test_ipv4_to_str_from_int(self):
ipv4_int = 169657601
val = '10.28.197.1'
res = ip.ipv4_to_str(ipv4_int)
eq_(val, res)
def test_ipv4_to_str_from_bin(self):
ipv4_bin = struct.pack('!I', 0x0a1cc501)
val = '10.28.197.1'
res = ip.ipv4_to_str(ipv4_bin)
eq_(val, res)
def _packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
dst, src, _eth_type = struct.unpack_from('!6s6sH', buffer(msg.data), 0)
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
match = msg.match
in_port = 0
ethtype = 0
#iterate through fields - parser should handle this
#packet in dpid 20015998343868 from 08:00:27:15:d4:53 to ff:ff:ff:ff:ff:ff log_port 0 phy_port 0
#Field MTInPort(header=2147483652,length=8,n_bytes=4,value=2)
#Field MTEthType(header=2147486210,length=6,n_bytes=2,value=2054)
#Field MTArpOp(header=2147494402,length=6,n_bytes=2,value=1)
#Field MTMetadata(header=2147484680,length=12,n_bytes=8,value=18446744073709551615L)
#Field MTArpSha(header=2147495942,length=10,n_bytes=6,value="\x08\x00'\x15\xd4S")
#Field MTEthDst(header=2147485190,length=10,n_bytes=6,value='\xff\xff\xff\xff\xff\xff')
#Field MTArpSpa(header=2147494916,length=8,n_bytes=4,value=167772161)
#Field MTArpTha(header=2147496454,length=10,n_bytes=6,value='\x00\x00\x00\x00\x00\x00')
# we should build a dictionary of MTXXXX class names to speed this up
for o in match.fields:
self.logger.info("Field %s", str(o))
if isinstance(o, ofproto_v1_2_parser.MTInPort):
in_port = o.value
break
self.logger.info("packet in dpid %s from %s to %s log_port %s",
dpid, haddr_to_str(src), haddr_to_str(dst),
in_port)
# parse packet
pkt = packet.Packet(msg.data)
eth_pkt = pkt.next()
ethtype = eth_pkt.ethertype
# if ARP (request) then flood and don't make a flow
if ethtype == ether.ETH_TYPE_ARP:
# if ARP reply then drop
arp_pkt = pkt.next()
if arp_pkt.opcode == 2:
# check config
if ip.ipv4_to_bin(spe_config.ports[in_port]) != arp_pkt.src_ip:
self.logger.info("Dropping spoofed ARP from port %d IP %s (expected IP %s)", in_port, ip.ipv4_to_str(arp_pkt.src_ip), spe_config.ports[in_port])
return
out_port = ofproto_v1_2.OFPP_FLOOD
actions = [datapath.ofproto_parser.OFPActionOutput(out_port, 1500)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port,
actions=actions)
datapath.send_msg(out)
# do we know the mac?
if src not in self.mac_to_port[dpid]:
# learn the mac address to avoid FLOOD next time.
self.mac_to_port[dpid][src] = in_port
# set a flow to table 0 to allow packets through to table 1
match = datapath.ofproto_parser.OFPMatch()
match.set_in_port(in_port)
match.set_dl_src(src)
match.set_dl_type(ethtype)
instructions = [datapath.ofproto_parser.OFPInstructionGotoTable(2)]
self.add_flow(datapath, 0, match, instructions)
if dst in self.mac_to_port[dpid]:
out_port = self.mac_to_port[dpid][dst]
match = datapath.ofproto_parser.OFPMatch()
match.set_dl_dst(dst)
actions = [datapath.ofproto_parser.OFPActionOutput(out_port, 1500)]
instructions = [datapath.ofproto_parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
self.add_flow(datapath, 2, match, instructions, buffer_id=msg.buffer_id)
else:
out_port = ofproto_v1_2.OFPP_FLOOD
actions = [datapath.ofproto_parser.OFPActionOutput(out_port, 1500)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port,
actions=actions)
datapath.send_msg(out)
def test_ipv4_to_str(self):
ipv4_bin = 0x0a1cc501
val = '10.28.197.1'
res = ip.ipv4_to_str(ipv4_bin)
eq_(val, res)
def test_arp(self):
# buid packet
e = ethernet.ethernet(self.dst_mac, self.src_mac,
ether.ETH_TYPE_ARP)
a = arp.arp(1, ether.ETH_TYPE_IP, 6, 4, 2,
self.src_mac, self.src_ip, self.dst_mac,
self.dst_ip)
p = packet.Packet()
p.add_protocol(e)
p.add_protocol(a)
p.serialize()
# ethernet !6s6sH
e_buf = self.dst_mac \
+ self.src_mac \
+ '\x08\x06'
# arp !HHBBH6sI6sI
a_buf = '\x00\x01' \
+ '\x08\x00' \
+ '\x06' \
+ '\x04' \
+ '\x00\x02' \
+ self.src_mac \
+ self.src_ip_bin \
+ self.dst_mac \
+ self.dst_ip_bin
buf = e_buf + a_buf
eq_(buf, p.data)
# parse
pkt = packet.Packet(array.array('B', p.data))
protocols = self.get_protocols(pkt)
p_eth = protocols['ethernet']
p_arp = protocols['arp']
# ethernet
ok_(p_eth)
eq_(self.dst_mac, p_eth.dst)
eq_(self.src_mac, p_eth.src)
eq_(ether.ETH_TYPE_ARP, p_eth.ethertype)
# arp
ok_(p_arp)
eq_(1, p_arp.hwtype)
eq_(ether.ETH_TYPE_IP, p_arp.proto)
eq_(6, p_arp.hlen)
eq_(4, p_arp.plen)
eq_(2, p_arp.opcode)
eq_(self.src_mac, p_arp.src_mac)
eq_(self.src_ip, p_arp.src_ip)
eq_(self.dst_mac, p_arp.dst_mac)
eq_(self.dst_ip, p_arp.dst_ip)
# to string
eth_values = {'dst': mac.haddr_to_str(self.dst_mac),
'src': mac.haddr_to_str(self.src_mac),
'ethertype': '0x%04x' % ether.ETH_TYPE_ARP}
_eth_str = ','.join(['%s=%s' % (k, repr(eth_values[k]))
for k, v in inspect.getmembers(p_eth)
if k in eth_values])
eth_str = '%s(%s)' % (ethernet.ethernet.__name__, _eth_str)
arp_values = {'hwtype': 1,
'proto': '0x%04x' % ether.ETH_TYPE_IP,
'hlen': 6,
'plen': 4,
'opcode': 2,
'src_mac': mac.haddr_to_str(self.src_mac),
'dst_mac': mac.haddr_to_str(self.dst_mac),
'src_ip': ipv4_to_str(self.src_ip),
'dst_ip': ipv4_to_str(self.dst_ip)}
_arp_str = ','.join(['%s=%s' % (k, repr(arp_values[k]))
for k, v in inspect.getmembers(p_arp)
if k in arp_values])
arp_str = '%s(%s)' % (arp.arp.__name__, _arp_str)
pkt_str = '%s, %s' % (eth_str, arp_str)
eq_(eth_str, str(p_eth))
eq_(eth_str, repr(p_eth))
eq_(arp_str, str(p_arp))
eq_(arp_str, repr(p_arp))
eq_(pkt_str, str(pkt))
eq_(pkt_str, repr(pkt))
def test_ipv4_tcp(self):
# buid packet
e = ethernet.ethernet(self.dst_mac, self.src_mac,
ether.ETH_TYPE_IP)
ip = ipv4.ipv4(4, 5, 0, 0, 0, 0, 0, 64, inet.IPPROTO_TCP, 0,
self.src_ip, self.dst_ip)
t = tcp.tcp(0x190F, 0x1F90, 0x123, 1, 6, 0b101010, 2048, 0, 0x6f,
'\x01\x02')
p = packet.Packet()
p.add_protocol(e)
p.add_protocol(ip)
p.add_protocol(t)
p.add_protocol(self.payload)
p.serialize()
# ethernet !6s6sH
e_buf = self.dst_mac \
+ self.src_mac \
+ '\x08\x00'
# ipv4 !BBHHHBBHII
ip_buf = '\x45' \
+ '\x00' \
+ '\x00\x4C' \
+ '\x00\x00' \
+ '\x00\x00' \
+ '\x40' \
+ '\x06' \
+ '\x00\x00' \
+ self.src_ip_bin \
+ self.dst_ip_bin
# tcp !HHIIBBHHH + option
t_buf = '\x19\x0F' \
+ '\x1F\x90' \
+ '\x00\x00\x01\x23' \
+ '\x00\x00\x00\x01' \
+ '\x60' \
+ '\x2A' \
+ '\x08\x00' \
+ '\x00\x00' \
+ '\x00\x6F' \
+ '\x01\x02\x00\x00'
buf = e_buf + ip_buf + t_buf + self.payload
# parse
pkt = packet.Packet(array.array('B', p.data))
protocols = self.get_protocols(pkt)
p_eth = protocols['ethernet']
p_ipv4 = protocols['ipv4']
p_tcp = protocols['tcp']
# ethernet
ok_(p_eth)
eq_(self.dst_mac, p_eth.dst)
eq_(self.src_mac, p_eth.src)
eq_(ether.ETH_TYPE_IP, p_eth.ethertype)
# ipv4
ok_(p_ipv4)
eq_(4, p_ipv4.version)
eq_(5, p_ipv4.header_length)
eq_(0, p_ipv4.tos)
l = len(ip_buf) + len(t_buf) + len(self.payload)
eq_(l, p_ipv4.total_length)
eq_(0, p_ipv4.identification)
eq_(0, p_ipv4.flags)
eq_(64, p_ipv4.ttl)
eq_(inet.IPPROTO_TCP, p_ipv4.proto)
eq_(self.src_ip, p_ipv4.src)
eq_(self.dst_ip, p_ipv4.dst)
t = bytearray(ip_buf)
struct.pack_into('!H', t, 10, p_ipv4.csum)
eq_(packet_utils.checksum(t), 0)
# tcp
ok_(p_tcp)
eq_(0x190f, p_tcp.src_port)
eq_(0x1F90, p_tcp.dst_port)
eq_(0x123, p_tcp.seq)
eq_(1, p_tcp.ack)
eq_(6, p_tcp.offset)
eq_(0b101010, p_tcp.bits)
eq_(2048, p_tcp.window_size)
eq_(0x6f, p_tcp.urgent)
eq_(len(t_buf), len(p_tcp))
t = bytearray(t_buf)
struct.pack_into('!H', t, 16, p_tcp.csum)
ph = struct.pack('!IIBBH', self.src_ip, self.dst_ip, 0,
6, len(t_buf) + len(self.payload))
t = ph + t + self.payload
eq_(packet_utils.checksum(t), 0)
# payload
ok_('payload' in protocols)
eq_(self.payload, protocols['payload'].tostring())
# to string
eth_values = {'dst': mac.haddr_to_str(self.dst_mac),
'src': mac.haddr_to_str(self.src_mac),
'ethertype': '0x%04x' % ether.ETH_TYPE_IP}
_eth_str = ','.join(['%s=%s' % (k, repr(eth_values[k]))
for k, v in inspect.getmembers(p_eth)
if k in eth_values])
eth_str = '%s(%s)' % (ethernet.ethernet.__name__, _eth_str)
ipv4_values = {'version': 4,
'header_length': 5,
'tos': 0,
'total_length': l,
'identification': '0x%x' % 0,
'flags': '0x%02x' % 0,
'offset': p_ipv4.offset,
'ttl': 64,
'proto': inet.IPPROTO_TCP,
'csum': '0x%x' % p_ipv4.csum,
'src': ipv4_to_str(self.src_ip),
'dst': ipv4_to_str(self.dst_ip),
'option': None}
_ipv4_str = ','.join(['%s=%s' % (k, repr(ipv4_values[k]))
for k, v in inspect.getmembers(p_ipv4)
if k in ipv4_values])
ipv4_str = '%s(%s)' % (ipv4.ipv4.__name__, _ipv4_str)
tcp_values = {'src_port': 0x190f,
'dst_port': 0x1F90,
'seq': 0x123,
'ack': 1,
'offset': 6,
'bits': format(0b101010, '09b'),
'window_size': 2048,
'csum': '0x%x' % p_tcp.csum,
'urgent': 0x6f,
'option': p_tcp.option}
_tcp_str = ','.join(['%s=%s' % (k, repr(tcp_values[k]))
for k, v in inspect.getmembers(p_tcp)
if k in tcp_values])
tcp_str = '%s(%s)' % (tcp.tcp.__name__, _tcp_str)
pkt_str = '%s, %s, %s, %s' % (eth_str, ipv4_str, tcp_str,
repr(protocols['payload']))
eq_(eth_str, str(p_eth))
eq_(eth_str, repr(p_eth))
eq_(ipv4_str, str(p_ipv4))
eq_(ipv4_str, repr(p_ipv4))
eq_(tcp_str, str(p_tcp))
eq_(tcp_str, repr(p_tcp))
eq_(pkt_str, str(pkt))
eq_(pkt_str, repr(pkt))
def test_ipv4_udp(self):
# buid packet
e = ethernet.ethernet(self.dst_mac, self.src_mac,
ether.ETH_TYPE_IP)
ip = ipv4.ipv4(4, 5, 1, 0, 3, 1, 4, 64, inet.IPPROTO_UDP, 0,
self.src_ip, self.dst_ip)
u = udp.udp(0x190F, 0x1F90, 0, 0)
p = packet.Packet()
p.add_protocol(e)
p.add_protocol(ip)
p.add_protocol(u)
p.add_protocol(self.payload)
p.serialize()
# ethernet !6s6sH
e_buf = self.dst_mac \
+ self.src_mac \
+ '\x08\x00'
# ipv4 !BBHHHBBHII
ip_buf = '\x45' \
+ '\x01' \
+ '\x00\x3C' \
+ '\x00\x03' \
+ '\x20\x04' \
+ '\x40' \
+ '\x11' \
+ '\x00\x00' \
+ self.src_ip_bin \
+ self.dst_ip_bin
# udp !HHHH
u_buf = '\x19\x0F' \
+ '\x1F\x90' \
+ '\x00\x28' \
+ '\x00\x00'
buf = e_buf + ip_buf + u_buf + self.payload
# parse
pkt = packet.Packet(array.array('B', p.data))
protocols = self.get_protocols(pkt)
p_eth = protocols['ethernet']
p_ipv4 = protocols['ipv4']
p_udp = protocols['udp']
# ethernet
ok_(p_eth)
eq_(self.dst_mac, p_eth.dst)
eq_(self.src_mac, p_eth.src)
eq_(ether.ETH_TYPE_IP, p_eth.ethertype)
# ipv4
ok_(p_ipv4)
eq_(4, p_ipv4.version)
eq_(5, p_ipv4.header_length)
eq_(1, p_ipv4.tos)
l = len(ip_buf) + len(u_buf) + len(self.payload)
eq_(l, p_ipv4.total_length)
eq_(3, p_ipv4.identification)
eq_(1, p_ipv4.flags)
eq_(64, p_ipv4.ttl)
eq_(inet.IPPROTO_UDP, p_ipv4.proto)
eq_(self.src_ip, p_ipv4.src)
eq_(self.dst_ip, p_ipv4.dst)
t = bytearray(ip_buf)
struct.pack_into('!H', t, 10, p_ipv4.csum)
eq_(packet_utils.checksum(t), 0)
# udp
ok_(p_udp)
eq_(0x190f, p_udp.src_port)
eq_(0x1F90, p_udp.dst_port)
eq_(len(u_buf) + len(self.payload), p_udp.total_length)
eq_(0x77b2, p_udp.csum)
t = bytearray(u_buf)
struct.pack_into('!H', t, 6, p_udp.csum)
ph = struct.pack('!IIBBH', self.src_ip, self.dst_ip, 0,
17, len(u_buf) + len(self.payload))
t = ph + t + self.payload
eq_(packet_utils.checksum(t), 0)
# payload
ok_('payload' in protocols)
eq_(self.payload, protocols['payload'].tostring())
# to string
eth_values = {'dst': mac.haddr_to_str(self.dst_mac),
'src': mac.haddr_to_str(self.src_mac),
'ethertype': '0x%04x' % ether.ETH_TYPE_IP}
_eth_str = ','.join(['%s=%s' % (k, repr(eth_values[k]))
for k, v in inspect.getmembers(p_eth)
if k in eth_values])
eth_str = '%s(%s)' % (ethernet.ethernet.__name__, _eth_str)
ipv4_values = {'version': 4,
'header_length': 5,
'tos': 1,
'total_length': l,
'identification': '0x%x' % 3,
'flags': '0x%02x' % 1,
'offset': p_ipv4.offset,
'ttl': 64,
'proto': inet.IPPROTO_UDP,
'csum': '0x%x' % p_ipv4.csum,
'src': ipv4_to_str(self.src_ip),
'dst': ipv4_to_str(self.dst_ip),
'option': None}
_ipv4_str = ','.join(['%s=%s' % (k, repr(ipv4_values[k]))
for k, v in inspect.getmembers(p_ipv4)
if k in ipv4_values])
ipv4_str = '%s(%s)' % (ipv4.ipv4.__name__, _ipv4_str)
udp_values = {'src_port': 0x190f,
'dst_port': 0x1F90,
'total_length': len(u_buf) + len(self.payload),
'csum': '0x%x' % 0x77b2}
_udp_str = ','.join(['%s=%s' % (k, repr(udp_values[k]))
for k, v in inspect.getmembers(p_udp)
if k in udp_values])
udp_str = '%s(%s)' % (udp.udp.__name__, _udp_str)
pkt_str = '%s, %s, %s, %s' % (eth_str, ipv4_str, udp_str,
repr(protocols['payload']))
eq_(eth_str, str(p_eth))
eq_(eth_str, repr(p_eth))
eq_(ipv4_str, str(p_ipv4))
eq_(ipv4_str, repr(p_ipv4))
eq_(udp_str, str(p_udp))
eq_(udp_str, repr(p_udp))
eq_(pkt_str, str(pkt))
eq_(pkt_str, repr(pkt))
def test_ipv4_to_str_from_int(self):
ipv4_int = 169657601
val = '10.28.197.1'
res = ip.ipv4_to_str(ipv4_int)
eq_(val, res)
def test_ipv4_to_str_from_bin(self):
ipv4_bin = struct.pack('!I', 0x0a1cc501)
val = '10.28.197.1'
res = ip.ipv4_to_str(ipv4_bin)
eq_(val, res)
