def __init__(self, *args, **kwargs):
super(DPIController, self).__init__(*args, **kwargs)
self.tbl_num = self._service_manager.get_table_num(self.APP_NAME)
self.next_table = self._service_manager.get_next_table_num(
self.APP_NAME)
self.setup_type = kwargs['config']['setup_type']
self._datapath = None
self._dpi_enabled = kwargs['config']['dpi']['enabled']
self._mon_port = kwargs['config']['dpi']['mon_port']
self._mon_port_number = kwargs['config']['dpi']['mon_port_number']
self._idle_timeout = kwargs['config']['dpi']['idle_timeout']
self._bridge_name = kwargs['config']['bridge_name']
self._app_set_tbl_num = self._service_manager.INTERNAL_APP_SET_TABLE_NUM
self._imsi_set_tbl_num = \
self._service_manager.INTERNAL_IMSI_SET_TABLE_NUM
if self._dpi_enabled:
self._create_monitor_port()
tcp_pkt = packet.Packet()
tcp_pkt.add_protocol(
ethernet.ethernet(ethertype=ether_types.ETH_TYPE_IP))
tcp_pkt.add_protocol(ipv4.ipv4(proto=6))
tcp_pkt.add_protocol(tcp.tcp())
tcp_pkt.serialize()
self.tcp_pkt_data = tcp_pkt.data
udp_pkt = packet.Packet()
udp_pkt.add_protocol(
ethernet.ethernet(ethertype=ether_types.ETH_TYPE_IP))
udp_pkt.add_protocol(ipv4.ipv4(proto=17))
udp_pkt.add_protocol(udp.udp())
udp_pkt.serialize()
self.udp_pkt_data = udp_pkt.data
def test_default_args(self):
prev = ipv4(proto=inet.IPPROTO_IGMP)
g = igmpv3_report()
prev.serialize(g, None)
buf = g.serialize(bytearray(), prev)
res = unpack_from(igmpv3_report._PACK_STR, six.binary_type(buf))
buf = bytearray(buf)
pack_into('!H', buf, 2, 0)
eq_(res[0], IGMP_TYPE_REPORT_V3)
eq_(res[1], checksum(buf))
eq_(res[2], 0)
# records without record_num
prev = ipv4(proto=inet.IPPROTO_IGMP)
record1 = igmpv3_report_group(MODE_IS_INCLUDE, 0, 0, '225.0.0.1')
record2 = igmpv3_report_group(MODE_IS_INCLUDE, 0, 2, '225.0.0.2',
['172.16.10.10', '172.16.10.27'])
record3 = igmpv3_report_group(MODE_IS_INCLUDE, 1, 0, '225.0.0.3', [],
b'abc\x00')
record4 = igmpv3_report_group(MODE_IS_INCLUDE, 1, 2, '225.0.0.4',
['172.16.10.10', '172.16.10.27'],
b'abc\x00')
records = [record1, record2, record3, record4]
g = igmpv3_report(records=records)
prev.serialize(g, None)
buf = g.serialize(bytearray(), prev)
res = unpack_from(igmpv3_report._PACK_STR, six.binary_type(buf))
buf = bytearray(buf)
pack_into('!H', buf, 2, 0)
eq_(res[0], IGMP_TYPE_REPORT_V3)
eq_(res[1], checksum(buf))
eq_(res[2], len(records))
def test_default_args(self):
prev = ipv4(proto=inet.IPPROTO_IGMP)
g = igmpv3_report()
prev.serialize(g, None)
buf = g.serialize(bytearray(), prev)
res = unpack_from(igmpv3_report._PACK_STR, six.binary_type(buf))
buf = bytearray(buf)
pack_into("!H", buf, 2, 0)
eq_(res[0], IGMP_TYPE_REPORT_V3)
eq_(res[1], checksum(buf))
eq_(res[2], 0)
# records without record_num
prev = ipv4(proto=inet.IPPROTO_IGMP)
record1 = igmpv3_report_group(MODE_IS_INCLUDE, 0, 0, "225.0.0.1")
record2 = igmpv3_report_group(MODE_IS_INCLUDE, 0, 2, "225.0.0.2", ["172.16.10.10", "172.16.10.27"])
record3 = igmpv3_report_group(MODE_IS_INCLUDE, 1, 0, "225.0.0.3", [], b"abc\x00")
record4 = igmpv3_report_group(MODE_IS_INCLUDE, 1, 2, "225.0.0.4", ["172.16.10.10", "172.16.10.27"], b"abc\x00")
records = [record1, record2, record3, record4]
g = igmpv3_report(records=records)
prev.serialize(g, None)
buf = g.serialize(bytearray(), prev)
res = unpack_from(igmpv3_report._PACK_STR, six.binary_type(buf))
buf = bytearray(buf)
pack_into("!H", buf, 2, 0)
eq_(res[0], IGMP_TYPE_REPORT_V3)
eq_(res[1], checksum(buf))
eq_(res[2], len(records))
def build_pkt(pkt):
layers = []
if 'arp_target_ip' in pkt:
ethertype = 0x806
layers.append(arp.arp(dst_ip=pkt['arp_target_ip']))
elif 'ipv6_src' in pkt:
ethertype = 0x86DD
layers.append(ipv6.ipv6(src=pkt['ipv6_src'], dst=pkt['ipv6_src']))
else:
ethertype = 0x800
if 'ipv4_src' in pkt:
net = ipv4.ipv4(src=pkt['ipv4_src'], dst=pkt['ipv4_dst'])
else:
net = ipv4.ipv4()
layers.append(net)
if 'vid' in pkt:
tpid = 0x8100
layers.append(vlan.vlan(vid=pkt['vid'], ethertype=ethertype))
else:
tpid = ethertype
eth = ethernet.ethernet(
dst=pkt['eth_dst'],
src=pkt['eth_src'],
ethertype=tpid)
layers.append(eth)
result = packet.Packet()
for layer in layers:
result.add_protocol(layer)
return result
def build_pkt(pkt):
layers = []
if 'arp_target_ip' in pkt:
ethertype = 0x806
layers.append(arp.arp(dst_ip=pkt['arp_target_ip']))
elif 'ipv6_src' in pkt:
ethertype = 0x86DD
layers.append(ipv6.ipv6(src=pkt['ipv6_src'], dst=pkt['ipv6_src']))
else:
ethertype = 0x800
if 'ipv4_src' in pkt:
net = ipv4.ipv4(src=pkt['ipv4_src'], dst=pkt['ipv4_dst'])
else:
net = ipv4.ipv4()
layers.append(net)
if 'vid' in pkt:
tpid = 0x8100
layers.append(vlan.vlan(vid=pkt['vid'], ethertype=ethertype))
else:
tpid = ethertype
eth = ethernet.ethernet(dst=pkt['eth_dst'],
src=pkt['eth_src'],
ethertype=tpid)
layers.append(eth)
result = packet.Packet()
for layer in layers:
result.add_protocol(layer)
return result
def _do_leave(self, leave, in_port, msg):
"""the process when the snooper received a LEAVE message."""
datapath = msg.datapath
dpid = datapath.id
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# check whether the querier port has been specified.
if not self._to_querier.get(dpid):
self.logger.info("no querier exists.")
return
# save this LEAVE message and reset the condition of the port
# that received this message.
self._to_hosts.setdefault(dpid, {})
self._to_hosts[dpid].setdefault(leave.address, {
'replied': False,
'leave': None,
'ports': {}
})
self._to_hosts[dpid][leave.address]['leave'] = msg
self._to_hosts[dpid][leave.address]['ports'][in_port] = {
'out': False,
'in': False
}
# create a specific query.
timeout = igmp.LAST_MEMBER_QUERY_INTERVAL
res_igmp = igmp.igmp(msgtype=igmp.IGMP_TYPE_QUERY,
maxresp=timeout * 10,
csum=0,
address=leave.address)
res_ipv4 = ipv4.ipv4(total_length=len(ipv4.ipv4()) + len(res_igmp),
proto=inet.IPPROTO_IGMP,
ttl=1,
src=self._to_querier[dpid]['ip'],
dst=igmp.MULTICAST_IP_ALL_HOST)
res_ether = ethernet.ethernet(dst=igmp.MULTICAST_MAC_ALL_HOST,
src=self._to_querier[dpid]['mac'],
ethertype=ether.ETH_TYPE_IP)
res_pkt = packet.Packet()
res_pkt.add_protocol(res_ether)
res_pkt.add_protocol(res_ipv4)
res_pkt.add_protocol(res_igmp)
res_pkt.serialize()
# send a specific query to the host that sent this message.
actions = [parser.OFPActionOutput(ofproto.OFPP_IN_PORT)]
self._do_packet_out(datapath, res_pkt.data, in_port, actions)
# wait for REPORT messages.
hub.spawn(self._do_timeout_for_leave, timeout, datapath, leave.address,
in_port)
def _do_leave(self, leave, in_port, msg):
"""the process when the snooper received a LEAVE message."""
datapath = msg.datapath
dpid = datapath.id
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
# check whether the querier port has been specified.
if not self._to_querier.get(dpid):
self.logger.info("no querier exists.")
return
# save this LEAVE message and reset the condition of the port
# that received this message.
self._to_hosts.setdefault(dpid, {})
self._to_hosts[dpid].setdefault(
leave.address,
{'replied': False, 'leave': None, 'ports': {}})
self._to_hosts[dpid][leave.address]['leave'] = msg
self._to_hosts[dpid][leave.address]['ports'][in_port] = {
'out': False, 'in': False}
# create a specific query.
timeout = igmp.LAST_MEMBER_QUERY_INTERVAL
res_igmp = igmp.igmp(
msgtype=igmp.IGMP_TYPE_QUERY,
maxresp=timeout * 10,
csum=0,
address=leave.address)
res_ipv4 = ipv4.ipv4(
total_length=len(ipv4.ipv4()) + len(res_igmp),
proto=inet.IPPROTO_IGMP, ttl=1,
src=self._to_querier[dpid]['ip'],
dst=igmp.MULTICAST_IP_ALL_HOST)
res_ether = ethernet.ethernet(
dst=igmp.MULTICAST_MAC_ALL_HOST,
src=self._to_querier[dpid]['mac'],
ethertype=ether.ETH_TYPE_IP)
res_pkt = packet.Packet()
res_pkt.add_protocol(res_ether)
res_pkt.add_protocol(res_ipv4)
res_pkt.add_protocol(res_igmp)
res_pkt.serialize()
# send a specific query to the host that sent this message.
actions = [parser.OFPActionOutput(ofproto.OFPP_IN_PORT)]
self._do_packet_out(datapath, res_pkt.data, in_port, actions)
# wait for REPORT messages.
hub.spawn(self._do_timeout_for_leave, timeout, datapath,
leave.address, in_port)
def match_to_packet(self, match):
pkt = packet.Packet()
l2 = ethernet.ethernet(
dst=match.setdefault('eth_dst', "00:00:00:00:00:02"),
src=match.setdefault('eth_src', "00:00:00:00:00:01"),
ethertype=match.setdefault('eth_type', 0x800)
)
pkt.add_protocol(l2)
if 'vlan_vid' in match:
pkt.get_protocol(ethernet.ethernet).ethertype=0x8100
vl = vlan.vlan(
pcp=0,
cfi=0,
vid=match['vlan_vid'],
ethertype=match['eth_type']
)
pkt.add_protocol(vl)
l3 = ipv4.ipv4(
src=match.setdefault('ipv4_src', "192.168.1.1"),
dst=match.setdefault('ipv4_dst', "192.168.1.2")
)
pkt.add_protocol(l3)
l4 = tcp.tcp(
src_port=match.setdefault('tcp_src', 12345),
dst_port=match.setdefault('tcp_dst', 80)
)
pkt.add_protocol(l4)
pkt.serialize()
return pkt
def send_ls_ack(self,ospf_pkt_ls_up):
### if success add
i=0
ack=[]
print ospf_pkt_ls_up.lsas
while i < len(ospf_pkt_ls_up.lsas):
ack.append(ospf_pkt_ls_up.lsas[i].header)
i+=1
msg = ospf.OSPFLSAck(router_id=self.router_id,
lsa_headers=ack)
rtr = self.routers
datapath = rtr.datapath
p = packet.Packet()
e = ethernet.ethernet(dst = '01:00:5e:00:00:05',src = '00:0c:29:d4:10:d7', ethertype = ether.ETH_TYPE_IP)
f = ipv4.ipv4(dst='224.0.0.5',
src='172.16.33.191',
proto=inet.IPPROTO_OSPF)
p.add_protocol(e)
p.add_protocol(f)
p.add_protocol(msg)
p.serialize()
actions = [datapath.ofproto_parser.OFPActionOutput(1)]
out = datapath.ofproto_parser.OFPPacketOut(datapath=datapath,
buffer_id=datapath.ofproto.OFP_NO_BUFFER,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
dist, previous = self.shortest_path()
self.update_fwd_table(dist, previous)
def build_packet_tcp_22():
"""
Build an SSH-like packet for use in tests.
"""
#ethernet(dst='08:00:27:1e:98:88',ethertype=2048,src='00:00:00:00:00:02')
#ipv4(csum=25158,dst='192.168.57.40',flags=2,header_length=5,
# identification=58864,offset=0,option=None,proto=6,src='192.168.56.12',
# tos=0,total_length=60,ttl=64,version=4)
#tcp(ack=0,bits=2,csum=60347,dst_port=22,offset=10,
# option='\x02\x04\x05\xb4\x04\x02\x08\n\x00\x08\x16\x0f\x00\x00\x00\x00\
# x01\x03\x03\x06'
# ,seq=533918719,src_port=52656,urgent=0,window_size=29200)
e = ethernet.ethernet(dst='00:00:00:00:00:02',
src='00:00:00:00:00:01',
ethertype=2048)
i = ipv4.ipv4(version=4, header_length=5, tos=0, total_length=0,
identification=0, flags=0, offset=0, ttl=255, proto=0,
csum=0, src='10.0.0.1', dst='10.0.0.2', option=None)
t = tcp.tcp(src_port=52656, dst_port=22, seq=533918719, ack=0, offset=10,
bits=2, window_size=29200, csum=0, urgent=0, option=None)
p = packet.Packet()
p.add_protocol(e)
p.add_protocol(i)
p.add_protocol(t)
p.serialize()
print repr(p.data) # the on-wire packet
return p
def handle_socket_msg(self):
pkt_eth = self._pkt.get_protocols(ethernet.ethernet)[0]
pkt_ip = self._pkt.get_protocols(ipv4.ipv4)[0]
pkt_udp = self._pkt.get_protocols(udp.udp)[0]
pkt_dns = DNS(self._pkt[-1])
print('----------------Sent query with ID', pkt_dns.id, pkt_dns)
if pkt_udp.dst_port == 53 or pkt_udp.src_port == 53:
#print 'A DNS query for controller is received'
if pkt_dns:
cs = self._controller.get_customers()
d_mac = cs[0].get_next_hop_mac()
pkt_dns.qr = 0
new_pkt = packet.Packet()
e = ethernet.ethernet(dst=cs[0].get_next_hop_mac(),
src=pkt_eth.src)
new_pkt.add_protocol(e)
new_pkt.add_protocol(
ipv4.ipv4(src=self._controller.get_ip(),
dst=cs[0].get_name_server(),
proto=17))
new_pkt.add_protocol(
udp.udp(src_port=pkt_udp.dst_port,
dst_port=pkt_udp.src_port))
new_dns = DNS(rd=0,
id=pkt_dns.id,
qd=DNSQR(qname=pkt_dns.qd.qname),
ns=DNSRR(rrname=pkt_dns.ar.rrname,
type=1,
ttl=60000,
rdata=cs[0].get_name_server()))
new_pkt.add_protocol(new_dns)
new_pkt.serialize()
self.send_dns_packet(new_pkt, cs[0].get_datapath(),
cs[0].get_ingress_port())
def handle_ip(self, datapath, in_port, pkt):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
ipv4_pkt = pkt.get_protocol(ipv4.ipv4) # parse out the IPv4 pkt
if datapath.id == 1 and ipv4_pkt.proto == inet.IPPROTO_TCP:
tcp_pkt = pkt.get_protocol(tcp.tcp) # parser out the TCP pkt
eth_pkt = pkt.get_protocol(ethernet.ethernet)
tcp_hd = tcp.tcp(ack=tcp_pkt.seq + 1,
src_port=tcp_pkt.dst_port,
dst_port=tcp_pkt.src_port,
bits=20)
ip_hd = ipv4.ipv4(dst=ipv4_pkt.src,
src=ipv4_pkt.dst,
proto=ipv4_pkt.proto)
ether_hd = ethernet.ethernet(ethertype=ether.ETH_TYPE_IP,
dst=eth_pkt.src,
src=eth_pkt.dst)
tcp_rst_ack = packet.Packet()
tcp_rst_ack.add_protocol(ether_hd)
tcp_rst_ack.add_protocol(ip_hd)
tcp_rst_ack.add_protocol(tcp_hd)
tcp_rst_ack.serialize()
actions = [parser.OFPActionOutput(in_port)]
out = parser.OFPPacketOut(datapath, ofproto.OFP_NO_BUFFER,
ofproto.OFPP_CONTROLLER, actions,
tcp_rst_ack.data)
datapath.send_msg(out)
def packet_in_handler(self, ev):
pkt = packet.Packet()
pkt.add_protocol(ethernet.ethernet(ethertype=0x0800, dst='00:00:00:00:00:02', src='00:00:00:00:00:01'))
pkt.add_protocol(ipv4.ipv4(dst='10.0.0.2', src='10.0.0.1', proto=17))
pkt.add_protocol(udp.udp(src_port=1000, dst_port=8000))
payload = b'Hellooooooooo~~~~~~~~~'
pkt.add_protocol(payload)
# Packet serializing
pkt.serialize()
data = pkt.data
msg = ev.msg
dp = msg.datapath
ofproto = dp.ofproto
actions = [dp.ofproto_parser.OFPActionOutput(2)]
out = dp.ofproto_parser.OFPPacketOut(
datapath=dp, buffer_id=ofproto.OFP_NO_BUFFER, in_port=msg.match['in_port'],
actions=actions, data=data)
dp.send_msg(out)
def test_serialize(self):
src_ip = netaddr.IPAddress('192.168.0.1').value
dst_ip = vrrp.VRRP_IPV4_DST_ADDRESS
prev = ipv4.ipv4(4, 5, 0, 0, 0, 0, 0, vrrp.VRRP_IPV4_TTL,
inet.IPPROTO_VRRP, 0, src_ip, dst_ip)
type_ = vrrp.VRRP_TYPE_ADVERTISEMENT
vrid = 5
priority = 10
max_adver_int = 30
ip_address = netaddr.IPAddress('192.168.0.2').value
ip_addresses = [ip_address]
vrrp_ = vrrp.vrrpv2.create(type_, vrid, priority, max_adver_int,
ip_addresses)
buf = vrrp_.serialize(bytearray(), prev)
pack_str = vrrp.vrrpv2._PACK_STR + 'III'
pack_len = struct.calcsize(pack_str)
res = struct.unpack(pack_str, str(buf))
eq_(res[0], vrrp.vrrp_to_version_type(vrrp.VRRP_VERSION_V2, type_))
eq_(res[1], vrid)
eq_(res[2], priority)
eq_(res[3], len(ip_addresses))
eq_(res[4], vrrp.VRRP_AUTH_NO_AUTH)
eq_(res[5], max_adver_int)
# res[6] is checksum
eq_(res[7], ip_address)
eq_(res[8], 0)
eq_(res[9], 0)
eq_(len(buf), pack_len)
# checksum
s = packet_utils.checksum(buf)
eq_(0, s)
def generateFINpkt(self):
ipv4_p = self.payload_pkt.get_protocol(ipv4.ipv4)
tcp_P = self.payload_pkt.get_protocol(tcp.tcp)
eth_p = self.payload_pkt.get_protocol(ethernet.ethernet)
e = ethernet.ethernet(dst=eth_p.dst, src=eth_p.src)
#ip = ipv4.ipv4(4, 5, ipv4_p.tos, 0, 0, 0, 0, 255, 6, 0, src=ipv4_p.dst, dst=ipv4_p.src, option=None)
#ip = ipv4.ipv4(4, 5, ipv4_p.tos, 0, ipv4_p.identification, ipv4_p.flags, 0, ipv4_p.ttl, ipv4_p.proto, 0, src=ipv4_p.src, dst=ipv4_p.dst, option=None)
ip = ipv4.ipv4(4,
5,
ipv4_p.tos,
0,
ipv4_p.identification,
ipv4_p.flags,
0,
ipv4_p.ttl,
ipv4_p.proto,
0,
src=ipv4_p.dst,
dst=ipv4_p.src,
option=None)
bits = 1 | 1 << 4
#tcpd = tcp.tcp(tcp_P.src_port, tcp_P.dst_port, tcp_P.seq, tcp_P.ack, 0, bits, tcp_P.window_size, 0, tcp_P.urgent, tcp_P.option)
tcpd = tcp.tcp(tcp_P.dst_port, tcp_P.src_port, tcp_P.seq, tcp_P.ack, 0,
bits, tcp_P.window_size, 0, tcp_P.urgent, tcp_P.option)
fin_pkt = packet.Packet()
fin_pkt.add_protocol(e)
fin_pkt.add_protocol(ip)
fin_pkt.add_protocol(tcpd)
fin_pkt.serialize()
print "FIN packet is generated."
return fin_pkt
def _set_redundancy(self, dpid, redundancy):
self.logger.info("Setting redundancy to: {}".format(redundancy))
datapath = get_datapath(self, dpid)
ofp = datapath.ofproto
ofp_parser = datapath.ofproto_parser
self.logger.info("Create OAM packet")
# pkt = copy.deepcopy(self.config_pkt)
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=ether_types.ETH_TYPE_IP,
dst='ff:ff:ff:ff:ff:ff',
src='00:00:00:00:00:0c'))
pkt.add_protocol(
ipv4.ipv4(dst="255.255.255.255",
src="0.0.0.0",
proto=in_proto.IPPROTO_UDP))
pkt.add_protocol(udp.udp(dst_port=common.UDP_PORT_OAM))
payload = struct.pack(">i", int(redundancy))
pkt.add_protocol(payload)
pkt.serialize()
data = pkt.data
in_port = ofp.OFPP_CONTROLLER
actions = [ofp_parser.OFPActionOutput(1)]
req = ofp_parser.OFPPacketOut(datapath, ofp.OFP_NO_BUFFER, in_port,
actions, data)
self.logger.info("Send OAM packet to encoder")
datapath.send_msg(req)
def flood(self, msg, seq, except_port=None):
size = len(msg)
buf_size = 1200
offset = 0
count = size / buf_size + 1
while size > 0:
frag = msg[offset:offset + buf_size]
offset = offset + buf_size
size = size - buf_size
pkt_data = json.dumps({'seq': seq, 'count': count, 'data': frag})
p = packet.Packet()
eth_header = ethernet.ethernet()
ip_header = ipv4.ipv4(proto=MULTIJET_IP_PROTO)
ip_header.serialize(pkt_data, eth_header)
p.add_protocol(eth_header)
p.add_protocol(ip_header)
p.add_protocol(pkt_data)
ofp = self.dp.ofproto
parser = self.dp.ofproto_parser
p.serialize()
data = p.data
actions = [parser.OFPActionOutput(ofp.OFPP_FLOOD)]
if except_port is None:
except_port = ofp.OFPP_CONTROLLER
out = parser.OFPPacketOut(datapath=self.dp,
buffer_id=ofp.OFP_NO_BUFFER,
in_port=except_port,
actions=actions,
data=data)
self.dp.send_msg(out)
log('flood finished')
def build_carp_ad_packet(src_mac):
# 16 bit for ip layer identification length
# getrandbits return long int
identification = int(random.getrandbits(16))
#total 3 bit in flags
#position 0 : reserved
#position 1 : don't fragment
#position 2 : more fragment
flags = 0b010
eth_pkt = ethernet.ethernet(dst=vrrp.VRRP_IPV4_DST_MAC_ADDRESS,
#src=vrrp_ipv4_src_mac_address(CONF.CARP.VRID),
src=src_mac,
ethertype=ether_types.ETH_TYPE_IP)
ip_pkt = ipv4.ipv4( identification=identification,
flags=flags,
ttl=vrrp.VRRP_IPV4_TTL,
proto=in_proto.IPPROTO_VRRP,
dst=vrrp.VRRP_IPV4_DST_ADDRESS)
carp_pkt = vrrp.vrrpv2.create(type_=vrrp.VRRP_TYPE_ADVERTISEMENT,vrid=CONF.CARP.VRID,
priority=0,max_adver_int=1,ip_addresses=[CONF.PARAMETER.LOGICAL_IP])
p = packet.Packet()
p.add_protocol(eth_pkt)
p.add_protocol(ip_pkt)
p.add_protocol(carp_pkt)
return p
def test_serialize_option(self):
# prepare test data
offset = 0
csum = 0
option = [
tcp.TCPOptionMaximumSegmentSize(max_seg_size=1460),
tcp.TCPOptionSACKPermitted(),
tcp.TCPOptionTimestamps(ts_val=287454020, ts_ecr=1432778632),
tcp.TCPOptionNoOperation(),
tcp.TCPOptionWindowScale(shift_cnt=9),
]
option_buf = b"\x02\x04\x05\xb4" b"\x04\x02" b"\x08\x0a\x11\x22\x33\x44\x55\x66\x77\x88" b"\x01" b"\x03\x03\x09"
prev = ipv4(4, 5, 0, 0, 0, 0, 0, 64, inet.IPPROTO_TCP, 0, "192.168.10.1", "192.168.100.1")
# test serializer
t = tcp.tcp(
self.src_port,
self.dst_port,
self.seq,
self.ack,
offset,
self.bits,
self.window_size,
csum,
self.urgent,
option,
)
buf = t.serialize(bytearray(), prev)
r_option_buf = buf[tcp.tcp._MIN_LEN : tcp.tcp._MIN_LEN + len(option_buf)]
eq_(option_buf, r_option_buf)
# test parser
(r_tcp, _, _) = tcp.tcp.parser(buf)
eq_(str(option), str(r_tcp.option))
def _handle_icmp(self, datapath, port, pkt_ethernet, pkt_ipv4, pkt_icmp):
"""
依据传入的 eth, ip, icmp 生成 packet包
:param datapath:
:param port:
:param pkt_ethernet:
:param pkt_ipv4:
:param pkt_icmp:
:return:
"""
if pkt_icmp.type != icmp.ICMP_ECHO_REQUEST:
return
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=pkt_ethernet.ethertype,
dst=pkt_ethernet.src,
src=self.hw_addr))
pkt.add_protocol(
ipv4.ipv4(dst=pkt_ipv4.src, src=self.ip_addr,
proto=pkt_ipv4.proto))
pkt.add_protocol(
icmp.icmp(type_=icmp.ICMP_ECHO_REPLY,
code=icmp.ICMP_ECHO_REPLY_CODE,
csum=0,
data=pkt_icmp.data))
self._send_packet(datapath, port, pkt)
def _handle_icmp(self, ev, subname):
msg = ev.msg
datapath = msg.datapath
pkt = packet.Packet(data=msg.data)
pkt_ethernet = pkt.get_protocol(ethernet.ethernet)
pkt_ipv4 = pkt.get_protocol(ipv4.ipv4)
pkt_icmp = pkt.get_protocol(icmp.icmp)
in_port = msg.match['in_port']
# ignore icmp of other than icmp_echo_request
if pkt_icmp.type != icmp.ICMP_ECHO_REQUEST:
return
# make packet object to return
this_subnet=self.subnet[datapath.id][subname]
pkt = packet.Packet()
pkt.add_protocol(ethernet.ethernet(ethertype=pkt_ethernet.ethertype,
dst=pkt_ethernet.src,
src=this_subnet['mac']))
# if vid != None:
# pkt.add_protocol(vlan.vlan(vid=vid, ethertype = 0x0800))
pkt.add_protocol(ipv4.ipv4(dst=pkt_ipv4.src,
src=this_subnet['ip'],
proto=pkt_ipv4.proto))
pkt.add_protocol(icmp.icmp(type_=icmp.ICMP_ECHO_REPLY,
code=icmp.ICMP_ECHO_REPLY_CODE,
csum=0,
data=pkt_icmp.data))
self._send_packet(datapath, in_port, pkt)
self.logger.info("icmp reply is sent: %s-%s via port=%s" % (pkt_ethernet.src, pkt_ipv4.src, in_port) )
def _handle_icmp(self, datapath, port, pkt_ethernet, pkt_ipv4, pkt_icmp,
SrcGroup):
# パケットがICMP ECHOリクエストでなかった場合はすぐに返す
# 自分のゲートウェイIPアドレスをもっているグループでなかったら終了
print('ICMP : ', pkt_ipv4.src, ' > ', pkt_ipv4.dst)
if pkt_icmp.type != icmp.ICMP_ECHO_REQUEST or pkt_ipv4.dst != self.group_mac[
SrcGroup][0][0]:
return
# ICMPを作成して返す
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=pkt_ethernet.ethertype,
dst=pkt_ethernet.src,
src=self.gateway_mac)) # ゲートウェイのmac
pkt.add_protocol(
ipv4.ipv4(
dst=pkt_ipv4.src,
src=self.group_mac[SrcGroup][0][0], # ゲートウェイのIP
proto=pkt_ipv4.proto))
pkt.add_protocol(
icmp.icmp(type_=icmp.ICMP_ECHO_REPLY,
code=icmp.ICMP_ECHO_REPLY_CODE,
csum=0,
data=pkt_icmp.data))
self._send_packet(datapath, port, pkt)
def build_new_packet(switch):
src_eth = switch['src_eth']
dst_eth = switch['dst_eth']
src_ip = switch['src_ip']
dst_ip = switch['dst_ip']
ip_id = switch['ip_id']
seq = switch['seq']
ack = switch['ack']
src_port = switch['src_port']
dst_port = switch['dst_port']
#eth proto
eth_pkt = ethernet.ethernet(src_eth,dst_eth,ethertype=ether_types.ETH_TYPE_IP)
#ip proto
ip_pkt = ipv4.ipv4(version=4, header_length=5,
tos=0, total_length=0,
identification=ip_id+1, flags=2,
offset=0, ttl=64,
proto=in_proto.IPPROTO_TCP, csum=0,
src=dst_ip, dst=src_ip)
#tcp proto
#psh ack bit
bits = 0b011000
tcp_pkt = tcp.tcp(src_port=dst_port, dst_port=src_port,
seq=ack, ack=seq, offset=0,
bits=bits, window_size=2048,
csum=0, urgent=0, option=None)
p = packet.Packet()
p.add_protocol(eth_pkt)
p.add_protocol(ip_pkt)
p.add_protocol(tcp_pkt)
return p
def assemble_ack(self, pkt):
req_eth = pkt.get_protocol(ethernet.ethernet)
req_ipv4 = pkt.get_protocol(ipv4.ipv4)
req_udp = pkt.get_protocol(udp.udp)
req = pkt.get_protocol(dhcp.dhcp)
req.options.option_list.remove(
next(opt for opt in req.options.option_list if opt.tag == 53))
req.options.option_list.insert(
0, dhcp.option(tag=51, value=bytes.fromhex('8640'.encode().hex())))
req.options.option_list.insert(0, dhcp.option(tag=53,
value=bytes([5])))
ack_pkt = packet.Packet()
ack_pkt.add_protocol(
ethernet.ethernet(ethertype=req_eth.ethertype,
dst=req_eth.src,
src=self.hw_addr))
ack_pkt.add_protocol(
ipv4.ipv4(dst=req_ipv4.dst,
src=self.dhcp_server,
proto=req_ipv4.proto))
ack_pkt.add_protocol(udp.udp(src_port=67, dst_port=68))
ack_pkt.add_protocol(
dhcp.dhcp(op=2,
chaddr=req_eth.src,
siaddr=self.dhcp_server,
boot_file=req.boot_file,
yiaddr=self._cal_vm_ip(req),
xid=req.xid,
options=req.options))
self.logger.info("ASSEMBLED ACK: %s" % ack_pkt)
return ack_pkt
def sendReply(self, sdonID, origMsg, action, reply):
datapath = origMsg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = origMsg.match['in_port']
if (action == "hello,"):
# save this SdonManager in the dictionary so we can contact that switch when we want
print "Saving " + str(sdonID) + "'s OF details."
self.sdonID_to_OF[sdonID] = [datapath, parser, in_port]
# Initialize the dictionary of Apps available for an SdonNode
# self.sdonID_to_apps[pubIp] = []
# Reply to the action message
pkt = packet.Packet()
e = ethernet.ethernet()
i = ipv4.ipv4(src="10.0.0.1", dst = "1.2.3.4")
# u = udp.udp()
pkt= e/i/(str(action) + str(reply))
pkt.serialize()
data = pkt.data
actions=[parser.OFPActionOutput(in_port)]
out = parser.OFPPacketOut(datapath=datapath,
buffer_id=ofproto.OFP_NO_BUFFER,
in_port=ofproto.OFPP_CONTROLLER,
actions=actions,
data=data)
datapath.send_msg(out)
def handle_packet(self):
pkt_ip = self._pkt.get_protocols(ipv4.ipv4)[0]
pkt_udp = self._pkt.get_protocols(udp.udp)[0]
cs = self._controller.get_customers()
index1 = self._controller.get_current_customer_id()
dns = DNS(self._pkt[-1])
print('------UDP---------', index1, cs[int(index1)].get_next_hop_mac(),
self._controller.get_transaction_id())
if self._controller.get_destination_nat(
) is not None and self._controller.get_transaction_id() is not None:
new_pkt = packet.Packet()
new_pkt.add_protocol(
ethernet.ethernet(src='10:00:00:00:10:ff',
dst=cs[int(index1)].get_next_hop_mac()))
new_pkt.add_protocol(
ipv4.ipv4(src=pkt_ip.src,
dst=cs[int(index1)].get_name_server(),
proto=17))
new_pkt.add_protocol(
udp.udp(src_port=pkt_udp.src_port, dst_port=pkt_udp.dst_port))
new_pkt.add_protocol(self._pkt[-1])
print('---------okt--------', new_pkt)
new_pkt.serialize()
print(
'----------------The Number of Exchanged PACKETS between Controllers-----',
self._controller.get_packet_counter())
self.send_dns_packet(new_pkt, cs[int(index1)].get_datapath(),
cs[int(index1)].get_ingress_port())
elif self._controller.get_destination_nat() is None:
self.send_dns_response_to_controller(self._pkt)
def test_serialize_with_auth_simple(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet('08:00:27:d1:95:7c', '08:00:27:ed:54:41')
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src='192.168.57.2', dst='192.168.57.1', tos=192,
identification=3216, proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
auth_cls = bfd.SimplePassword(auth_key_id=2,
password=self.auth_keys[2])
bfd_pkt = bfd.bfd(ver=1, diag=bfd.BFD_DIAG_NO_DIAG,
flags=bfd.BFD_FLAG_AUTH_PRESENT,
state=bfd.BFD_STATE_DOWN, detect_mult=3, my_discr=1,
your_discr=0, desired_min_tx_interval=1000000,
required_min_rx_interval=1000000,
required_min_echo_rx_interval=0,
auth_cls=auth_cls)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data_auth_simple)
def _build_vlan(self):
src_mac = mac.haddr_to_bin('00:07:0d:af:f4:54')
dst_mac = mac.haddr_to_bin('00:00:00:00:00:00')
ethertype = ether.ETH_TYPE_8021Q
e = ethernet(dst_mac, src_mac, ethertype)
version = 4
header_length = 20
tos = 0
total_length = 24
identification = 0x8a5d
flags = 0
offset = 1480
ttl = 64
proto = inet.IPPROTO_ICMP
csum = 0xa7f2
src = int(netaddr.IPAddress('131.151.32.21'))
dst = int(netaddr.IPAddress('131.151.32.129'))
option = 'TEST'
ip = ipv4(version, header_length, tos, total_length, identification,
flags, offset, ttl, proto, csum, src, dst, option)
p = Packet()
p.add_protocol(e)
p.add_protocol(self.v)
p.add_protocol(ip)
p.serialize()
return p
def assemble_ack(self, pkt):
req_eth = pkt.get_protocol(ethernet.ethernet)
req_ipv4 = pkt.get_protocol(ipv4.ipv4)
req_udp = pkt.get_protocol(udp.udp)
req = dhcp.dhcp.parser(pkt[3])
req[0].options.option_list.remove(
next(opt for opt in req[0].options.option_list if opt.tag == 53))
req[0].options.option_list.insert(0, dhcp.option(tag=51, value='8640'))
req[0].options.option_list.insert(
0, dhcp.option(tag=53, value='05'.decode('hex')))
ack_pkt = packet.Packet()
ack_pkt.add_protocol(
ethernet.ethernet(ethertype=req_eth.ethertype,
dst=req_eth.src,
src=self.hw_addr))
ack_pkt.add_protocol(
ipv4.ipv4(dst=req_ipv4.dst,
src=self.dhcp_server,
proto=req_ipv4.proto))
ack_pkt.add_protocol(udp.udp(src_port=67, dst_port=68))
ack_pkt.add_protocol(
dhcp.dhcp(op=2,
chaddr=req_eth.src,
siaddr=self.dhcp_server,
boot_file=req[0].boot_file,
yiaddr=self.ip_addr,
xid=req[0].xid,
options=req[0].options))
self.logger.info("ASSEMBLED ACK: %s" % ack_pkt)
return ack_pkt
def test_serialize_with_auth_sha1(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet("08:00:27:d1:95:7c", "08:00:27:ed:54:41")
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src="192.168.57.2", dst="192.168.57.1", tos=192, identification=2960, proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
auth_cls = bfd.KeyedSHA1(auth_key_id=2, seq=16817, auth_key=self.auth_keys[2])
bfd_pkt = bfd.bfd(
ver=1,
diag=bfd.BFD_DIAG_NO_DIAG,
flags=bfd.BFD_FLAG_AUTH_PRESENT,
state=bfd.BFD_STATE_DOWN,
detect_mult=3,
my_discr=1,
your_discr=0,
desired_min_tx_interval=1000000,
required_min_rx_interval=1000000,
required_min_echo_rx_interval=0,
auth_cls=auth_cls,
)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data_auth_sha1)
def assemble_ack(self, pkt):
response_eth = pkt.get_protocol(ethernet.ethernet)
response_ipv4 = pkt.get_protocol(ipv4.ipv4)
response = pkt.get_protocol(dhcp.dhcp)
response.options.option_list.remove(
next(opt for opt in response.options.option_list if opt.tag == 53))
response.options.option_list.insert(0, dhcp.option(tag=51, value=''))
response.options.option_list.insert(0, dhcp.option(tag=53, value=""))
ack_pkt = packet.Packet()
ack_pkt.add_protocol(
ethernet.ethernet(ethertype=response_eth.ethertype,
dst=response_eth.src,
src=""))
ack_pkt.add_protocol(
ipv4.ipv4(dst=response_ipv4.dst,
src=self.dhcp_server,
proto=response_ipv4.proto))
ack_pkt.add_protocol(udp.udp(src_port=67, dst_port=68))
ack_pkt.add_protocol(
dhcp.dhcp(op=2,
chaddr=response_eth.src,
siaddr="dhcp_server",
boot_file=response.boot_file,
yiaddr="ip_addr",
xid=response.xid,
options=response.options))
return ack_pkt
def send_ipv4_packet (self, datapath, port_no, hw_addr):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
pkt = packet.Packet()
pkt.add_protocol(ethernet.ethernet(ethertype=self.ipv4_type, src=hw_addr))
pkt.add_protocol(ipv4.ipv4(version=4,
header_length=5,
tos=0,
total_length=0,
identification=0,
flags=0,
offset=0,
ttl=0,
proto=0,
csum=0,
src='10.0.0.1',
dst='10.0.0.2',
option=None))
actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
out = parser.OFPPacketOut(datapath=datapath,
buffer_id=ofproto.OFP_NO_BUFFER,
in_port=ofproto.OFPP_CONTROLLER,
actions=actions,
data=data)
datapath.send_msg(out)
def assemble_ack(self, pkt, chaddr):
chaddr_yiaddr = self.get_ip(chaddr)
req_eth = pkt.get_protocol(ethernet.ethernet)
req_ipv4 = pkt.get_protocol(ipv4.ipv4)
req_udp = pkt.get_protocol(udp.udp)
req = pkt.get_protocol(dhcp.dhcp)
req.options.option_list.remove(
next(opt for opt in req.options.option_list if opt.tag == 53))
req.options.option_list.insert(
0, dhcp.option(tag=51, value=str.encode('8640')))
req.options.option_list.insert(
0, dhcp.option(tag=53, value=str.encode('\x05')))
ack_pkt = packet.Packet()
ack_pkt.add_protocol(
ethernet.ethernet(ethertype=req_eth.ethertype,
dst=req_eth.src,
src=self.hw_addr))
ack_pkt.add_protocol(
ipv4.ipv4(dst=req_ipv4.dst,
src=self.dhcp_server,
proto=req_ipv4.proto))
ack_pkt.add_protocol(udp.udp(src_port=67, dst_port=68))
ack_pkt.add_protocol(
dhcp.dhcp(op=2,
chaddr=req_eth.src,
siaddr=self.dhcp_server,
boot_file=req.boot_file,
yiaddr=chaddr_yiaddr,
xid=req.xid,
options=req.options))
self.logger.debug("ASSEMBLED ACK")
return ack_pkt
def assemble_offer(self, pkt):
disc_eth = pkt.get_protocol(ethernet.ethernet)
disc_ipv4 = pkt.get_protocol(ipv4.ipv4)
disc_udp = pkt.get_protocol(udp.udp)
disc = dhcp.dhcp.parser(pkt[3])
disc[0].options.option_list.remove(next(opt for opt in disc[0].options.option_list if opt.tag == 55))
disc[0].options.option_list.remove(next(opt for opt in disc[0].options.option_list if opt.tag == 53))
disc[0].options.option_list.remove(next(opt for opt in disc[0].options.option_list if opt.tag == 12))
disc[0].options.option_list.insert(0, dhcp.option(tag=1, value=self.bin_netmask))
disc[0].options.option_list.insert(0, dhcp.option(tag=3, value=self.bin_server))
disc[0].options.option_list.insert(0, dhcp.option(tag=6, value=self.bin_dns))
disc[0].options.option_list.insert(0, dhcp.option(tag=12, value=self.hostname))
disc[0].options.option_list.insert(0, dhcp.option(tag=53, value='02'.decode('hex')))
disc[0].options.option_list.insert(0, dhcp.option(tag=54, value=self.bin_server))
offer_pkt = packet.Packet()
offer_pkt.add_protocol(ethernet.ethernet(ethertype=disc_eth.ethertype, dst=disc_eth.src, src=self.hw_addr))
offer_pkt.add_protocol(ipv4.ipv4(dst=disc_ipv4.dst, src=self.dhcp_server, proto=disc_ipv4.proto))
offer_pkt.add_protocol(udp.udp(src_port=67,dst_port=68))
offer_pkt.add_protocol(dhcp.dhcp(op=2, chaddr=disc_eth.src,
siaddr=self.dhcp_server,
boot_file=disc[0].boot_file,
yiaddr=self.ip_addr,
xid=disc[0].xid,
options=disc[0].options))
self.logger.info("ASSEMBLED OFFER: %s" % offer_pkt)
return offer_pkt
def test_serialize(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet('b0:a8:6e:18:b8:08', '64:87:88:e9:cb:c8')
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src='172.28.3.1',
dst='172.28.3.2',
tos=192,
identification=26697,
proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
bfd_pkt = bfd.bfd(ver=1,
diag=bfd.BFD_DIAG_CTRL_DETECT_TIME_EXPIRED,
state=bfd.BFD_STATE_UP,
detect_mult=3,
my_discr=6,
your_discr=7,
desired_min_tx_interval=60000,
required_min_rx_interval=60000,
required_min_echo_rx_interval=0)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data)
def new_udp_pkt(eth_dst, eth_src, ip_dst, ip_src, src_port, dst_port, size=0):
# pcap_pen = pcaplib.Writer(open('pkt.pcap', 'wb'))
# Creat an empty Packet instance
pkt = packet.Packet()
pkt.add_protocol(ethernet.ethernet(ethertype=0x0800, dst=eth_dst,
src=eth_src))
pkt.add_protocol(ipv4.ipv4(dst=ip_dst, src=ip_src, proto=17))
pkt.add_protocol(udp.udp(src_port=src_port, dst_port=dst_port))
# Check how many byte be used under layer 3
_pkt = copy.deepcopy(pkt)
_pkt.serialize()
_d = _pkt.data
# the max. packet size is 1500 byte
limited_size = 1500 - len(_d)
# if size larger than 1500 byte set limit size
if size >= limited_size:
size = limited_size
if size != 0:
payload = os.urandom(size)
# Add payload
pkt.add_protocol(payload)
# Packet serializing
pkt.serialize()
data = pkt.data
# pcap_pen.write_pkt(data)
return data
def test_serialize(self):
src_port = 6431
dst_port = 8080
total_length = 0
csum = 0
src_ip = '192.168.10.1'
dst_ip = '192.168.100.1'
prev = ipv4(4, 5, 0, 0, 0, 0, 0, 64,
inet.IPPROTO_UDP, 0, src_ip, dst_ip)
u = udp(src_port, dst_port, total_length, csum)
buf = u.serialize(bytearray(), prev)
res = struct.unpack(udp._PACK_STR, buf)
eq_(res[0], src_port)
eq_(res[1], dst_port)
eq_(res[2], struct.calcsize(udp._PACK_STR))
# checksum
ph = struct.pack('!4s4sBBH',
addrconv.ipv4.text_to_bin(src_ip),
addrconv.ipv4.text_to_bin(dst_ip), 0, 17, res[2])
d = ph + buf + bytearray()
s = packet_utils.checksum(d)
eq_(0, s)
def generate_trace_pkt(entries, color, r_id):
'''
Receives the REST/PUT to generate a PacketOut
data needs to be serialized
template_trace.json is an example
'''
trace = {}
switch = {}
eth = {}
ip = {}
tp = {}
# TODO Validate for dl_vlan. If empty, return error.
dpid, in_port = 0, 65532
dl_src, dl_dst = "ca:fe:ca:fe:00:00", "ca:fe:ca:fe:ca:fe"
dl_vlan, dl_type = 100, 2048
nw_src, nw_dst, nw_tos = '127.0.0.1', '127.0.0.1', 0
tp_src, tp_dst = 1, 1
try:
trace = entries['trace']
switch = trace['switch']
eth = trace['eth']
ip = trace['ip']
tp = trace['tp']
except:
pass
if len(switch) > 0:
dpid, in_port = prepare_switch(switch, dpid, in_port)
if len(eth) > 0:
dl_src, dl_dst, dl_vlan, dl_type = prepare_ethernet(eth, dl_src, dl_dst,
dl_vlan, dl_type)
if len(ip) > 0:
nw_src, nw_dst, nw_tos = prepare_ip(ip, nw_src, nw_dst, nw_tos)
if len(tp) > 0:
tp_src, tp_dst = prepare_tp(tp, tp_src, tp_dst)
pkt = packet.Packet()
eth_pkt = ethernet.ethernet(dst=dl_dst, src=dl_src, ethertype=33024)
vlan_pkt = vlan.vlan(vid=dl_vlan, ethertype=dl_type, pcp=int(color, 2))
pkt.add_protocol(eth_pkt)
pkt.add_protocol(vlan_pkt)
if dl_type == 2048:
ip_pkt = ipv4.ipv4(dst=str(nw_dst), src=str(nw_src), tos=nw_tos,
proto=6)
pkt.add_protocol(ip_pkt)
tp_pkt = tcp.tcp(dst_port=tp_dst, src_port=tp_src)
pkt.add_protocol(tp_pkt)
data = str(r_id) # this will be the ID
pkt.add_protocol(data)
pkt.serialize()
return in_port, pkt
def test_serialize(self):
offset = 5
csum = 0
src_ip = '192.168.10.1'
dst_ip = '192.168.100.1'
prev = ipv4(4, 5, 0, 0, 0, 0, 0, 64, inet.IPPROTO_TCP, 0, src_ip,
dst_ip)
t = tcp(self.src_port, self.dst_port, self.seq, self.ack, offset,
self.bits, self.window_size, csum, self.urgent)
buf = t.serialize(bytearray(), prev)
res = struct.unpack(tcp._PACK_STR, str(buf))
eq_(res[0], self.src_port)
eq_(res[1], self.dst_port)
eq_(res[2], self.seq)
eq_(res[3], self.ack)
eq_(res[4], offset << 4)
eq_(res[5], self.bits)
eq_(res[6], self.window_size)
eq_(res[8], self.urgent)
# checksum
ph = struct.pack('!4s4sBBH', addrconv.ipv4.text_to_bin(src_ip),
addrconv.ipv4.text_to_bin(dst_ip), 0, 6, offset * 4)
d = ph + buf + bytearray()
s = packet_utils.checksum(d)
eq_(0, s)
def test_serialize(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet("b0:a8:6e:18:b8:08", "64:87:88:e9:cb:c8")
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src="172.28.3.1", dst="172.28.3.2", tos=192, identification=26697, proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
bfd_pkt = bfd.bfd(
ver=1,
diag=bfd.BFD_DIAG_CTRL_DETECT_TIME_EXPIRED,
state=bfd.BFD_STATE_UP,
detect_mult=3,
my_discr=6,
your_discr=7,
desired_min_tx_interval=60000,
required_min_rx_interval=60000,
required_min_echo_rx_interval=0,
)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data)
def _ping(self, dp, port_out):
ofp = dp.ofproto
parser = dp.ofproto_parser
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=0x0800,
dst='ff:ff:ff:ff:ff:ff',
src='aa:aa:aa:aa:aa:aa'))
pkt.add_protocol(ipv4.ipv4(dst='0.0.0.2', src='0.0.0.1', proto=1))
pkt.add_protocol(
icmp.icmp(type_=8,
code=0,
csum=0,
data=icmp.echo(
1, 1, "{'dpid' : " + str(dp.id) + ",'port_out' : " +
str(port_out) + "}")))
pkt.serialize()
data = pkt.data
actions = [parser.OFPActionOutput(port_out, 0)]
out = parser.OFPPacketOut(datapath=dp,
buffer_id=ofp.OFP_NO_BUFFER,
in_port=ofp.OFPP_CONTROLLER,
actions=actions,
data=data)
dp.send_msg(out)
def test_serialize_with_auth_sha1(self):
pkt = packet.Packet()
eth_pkt = ethernet.ethernet('08:00:27:d1:95:7c', '08:00:27:ed:54:41')
pkt.add_protocol(eth_pkt)
ip_pkt = ipv4.ipv4(src='192.168.57.2', dst='192.168.57.1', tos=192,
identification=2960, proto=inet.IPPROTO_UDP)
pkt.add_protocol(ip_pkt)
udp_pkt = udp.udp(49152, 3784)
pkt.add_protocol(udp_pkt)
auth_cls = bfd.KeyedSHA1(auth_key_id=2, seq=16817,
auth_key=self.auth_keys[2])
bfd_pkt = bfd.bfd(ver=1, diag=bfd.BFD_DIAG_NO_DIAG,
flags=bfd.BFD_FLAG_AUTH_PRESENT,
state=bfd.BFD_STATE_DOWN, detect_mult=3, my_discr=1,
your_discr=0, desired_min_tx_interval=1000000,
required_min_rx_interval=1000000,
required_min_echo_rx_interval=0,
auth_cls=auth_cls)
pkt.add_protocol(bfd_pkt)
eq_(len(pkt.protocols), 4)
pkt.serialize()
eq_(pkt.data, self.data_auth_sha1)
def handle_ip(self, datapath, in_port, pkt):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
ipv4_pkt = pkt.get_protocol(ipv4.ipv4) # parse out the IPv4 pkt
if datapath.id == 1 and ipv4_pkt.proto == inet.IPPROTO_TCP:
tcp_pkt = pkt.get_protocol(tcp.tcp) # parser out the TCP pkt
eth_pkt = pkt.get_protocol(ethernet.ethernet)
#if (tcp_pkt.bits) % 4 == 2:
tcp_hd = tcp.tcp(ack=tcp_pkt.seq+1, src_port = tcp_pkt.dst_port, dst_port = tcp_pkt.src_port, bits=20)
ip_hd = ipv4.ipv4(dst= ipv4_pkt.src, src= ipv4_pkt.dst, proto=ipv4_pkt.proto)
ether_hd = ethernet.ethernet(ethertype = ether.ETH_TYPE_IP, dst = eth_pkt.src, src = eth_pkt.dst)
tcp_rst_ack = packet.Packet()
tcp_rst_ack.add_protocol(ether_hd)
tcp_rst_ack.add_protocol(ip_hd)
tcp_rst_ack.add_protocol(tcp_hd)
tcp_rst_ack.serialize()
# generate the TCP packet with the RST flag set to 1
# packet generation is similar to ARP,
# but need to generate ethernet->ip->tcp and serialize it
# send the Packet Out mst to back to the host who is initilaizing the ARP
actions = [parser.OFPActionOutput(in_port)];
out = parser.OFPPacketOut(datapath, ofproto.OFP_NO_BUFFER,
ofproto.OFPP_CONTROLLER, actions,
tcp_rst_ack.data)
datapath.send_msg(out)
def test_serialize(self):
src_ip = netaddr.IPAddress('192.168.0.1').value
dst_ip = vrrp.VRRP_IPV4_DST_ADDRESS
prev = ipv4.ipv4(4, 5, 0, 0, 0, 0, 0, vrrp.VRRP_IPV4_TTL,
inet.IPPROTO_VRRP, 0, src_ip, dst_ip)
type_ = vrrp.VRRP_TYPE_ADVERTISEMENT
vrid = 5
priority = 10
max_adver_int = 30
ip_address = netaddr.IPAddress('192.168.0.2').value
ip_addresses = [ip_address]
vrrp_ = vrrp.vrrpv2.create(
type_, vrid, priority, max_adver_int, ip_addresses)
buf = vrrp_.serialize(bytearray(), prev)
pack_str = vrrp.vrrpv2._PACK_STR + 'III'
pack_len = struct.calcsize(pack_str)
res = struct.unpack(pack_str, str(buf))
eq_(res[0], vrrp.vrrp_to_version_type(vrrp.VRRP_VERSION_V2, type_))
eq_(res[1], vrid)
eq_(res[2], priority)
eq_(res[3], len(ip_addresses))
eq_(res[4], vrrp.VRRP_AUTH_NO_AUTH)
eq_(res[5], max_adver_int)
# res[6] is checksum
eq_(res[7], ip_address)
eq_(res[8], 0)
eq_(res[9], 0)
eq_(len(buf), pack_len)
# checksum
s = packet_utils.checksum(buf)
eq_(0, s)
def handle_ip(self, datapath, in_port, pkt):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
ipv4_pkt = pkt.get_protocol(ipv4.ipv4) # parse out the IPv4 pkt
if (datapath.id == 2
or datapath.id == 4) and ipv4_pkt.proto == inet.IPPROTO_TCP:
tcp_pkt = ipv4_pkt.get_protocol(tcp.tcp) # parser out the TCP pkt
### generate the TCP packet with the RST flag set to 1
### packet generation is similar to ARP,
### but you need to generate ethernet->ip->tcp and serialize it
eth_pkt = ipv4_dst.get_protocol(ethernet, ethernet)
tcp_hd = tcp.tcp(ack=tcp_pkt.seq + 1,
src_port=tcp_pkt.dst_port,
dst_port=tcp_pkt.src_port,
bits=20)
ip_hd = ipv4.ipv4(dst=ipv4_pkt.src,
src=ipv4_pkt.dst,
proto=ipv4_pkt.proto)
ether_hd = ethernet.ethernet(ethertype=ether.ETH_TYPE_IP,
dst=eth_pkt.src,
src=eth_pkt.dst)
tcp_rst_ack = packet.Packet()
tcp_rst_ack.add_protocol(ether_hd)
tcp_rst_ack.add_protocol(ip_hd)
tcp_rst_ack.add_protocol(tcp_hd)
tcp_rst_ack.serialize()
# send the Packet Out mst to back to the host who is initilaizing the ARP
actions = [parser.OFPActionOutput(in_port)]
out = parser.OFPPacketOut(datapath, ofproto.OFP_NO_BUFFER,
ofproto.OFPP_CONTROLLER, actions,
tcp_rst_ack.data)
datapath.send_msg(out)
def _handle_icmp(self, msg, port, data):
# パケットがICMP ECHOリクエストでなかった場合はすぐに返す
# 自分のゲートウェイIPアドレスをもっているグループでなかったら終了
pkt = packet.Packet(data)
pkt_icmp = pkt.get_protocol(icmp.icmp)
pkt_ethernet = pkt.get_protocol(ethernet.ethernet)
pkt_ipv4 = pkt.get_protocol(ipv4.ipv4)
if pkt_ipv4:
pass
else:
return
if pkt_icmp.type != icmp.ICMP_ECHO_REQUEST or pkt_ipv4.dst != self.gateway_ip:
return
src_mac = self.gateway_mac
src_ip = self.gateway_ip
dst_mac = pkt_ethernet.src
dst_ip = pkt_ipv4.src
print('ICMP : ', src_ip, ' >> ', dst_ip)
# ICMPを作成して返す
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=pkt_ethernet.ethertype,
dst=dst_mac,
src=src_mac)) # ゲートウェイのmac
pkt.add_protocol(
ipv4.ipv4(
dst=dst_ip,
src=src_ip, # ゲートウェイのIP
proto=pkt_ipv4.proto))
pkt.add_protocol(
icmp.icmp(type_=icmp.ICMP_ECHO_REPLY,
code=icmp.ICMP_ECHO_REPLY_CODE,
csum=0,
data=pkt_icmp.data))
self._send_packet(port, pkt, self.datapath.ofproto.OFP_NO_BUFFER)
def send_ping_packet(self, s1, s2):
'''
Send a ping/ICMP packet between two switches.
Uses ryu's packet library.
Uses a fake MAC and IP address only known to controller.
'''
datapath = self.datapath_list[int(s1.dpid)]
dst_mac = self.ping_mac
dst_ip = self.ping_ip
out_port = s1.port_no
actions = [datapath.ofproto_parser.OFPActionOutput(out_port)]
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=ether_types.ETH_TYPE_IP,
src=self.controller_mac,
dst=dst_mac))
pkt.add_protocol(
ipv4.ipv4(proto=in_proto.IPPROTO_ICMP,
src=self.controller_ip,
dst=dst_ip))
echo_payload = '%s;%s;%f' % (s1.dpid, s2.dpid, time.time())
payload = icmp.echo(data=echo_payload)
pkt.add_protocol(icmp.icmp(data=payload))
pkt.serialize()
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=datapath.ofproto.OFP_NO_BUFFER,
data=pkt.data,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions)
datapath.send_msg(out)
def send_ping_packet(self, switch, ip):
datapath = switch.dp
dpid = datapath.id
mac_dst = self.arp_table[ip]
out_port = self.mac_to_port[dpid][mac_dst]
actions = [datapath.ofproto_parser.OFPActionOutput(out_port)]
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=ether_types.ETH_TYPE_IP,
src=self.controller_mac,
dst=self.arp_table[ip]))
pkt.add_protocol(
ipv4.ipv4(proto=in_proto.IPPROTO_ICMP,
src=self.controller_ip,
dst=ip))
echo_payload = '%d;%s;%f' % (dpid, ip, time.time())
payload = icmp.echo(data=echo_payload)
pkt.add_protocol(icmp.icmp(data=payload))
pkt.serialize()
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=datapath.ofproto.OFP_NO_BUFFER,
data=pkt.data,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions)
datapath.send_msg(out)
def send_ospf_hello(self,signum, frame):
ospf_hello = ospf.OSPFHello(router_id = self.router_id ,neighbors = self.neighbors)
rtr = self.routers
datapath = rtr.datapath
hello = ospf_hello.serialize()
p = packet.Packet()
e = ethernet.ethernet(dst = '00:0c:29:9c:a6:82',src = '00:0c:29:52:9b:c4', ethertype = ether.ETH_TYPE_IP)
f = ipv4.ipv4(dst='192.168.66.195',
src='192.168.66.135',
proto=inet.IPPROTO_OSPF)
p.add_protocol(e)
p.add_protocol(f)
p.add_protocol(hello)
p.serialize()
print " ================= P.DATA =========== "
print p.data
print " ================= P.DATA =========== "
actions = [datapath.ofproto_parser.OFPActionOutput(6)]
out = datapath.ofproto_parser.OFPPacketOut(datapath=datapath,
buffer_id=datapath.ofproto.OFP_NO_BUFFER,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
self.call()
def test_serialize(self):
offset = 5
csum = 0
src_ip = '192.168.10.1'
dst_ip = '192.168.100.1'
prev = ipv4(4, 5, 0, 0, 0, 0, 0, 64,
inet.IPPROTO_TCP, 0, src_ip, dst_ip)
t = tcp(self.src_port, self.dst_port, self.seq, self.ack,
offset, self.bits, self.window_size, csum, self.urgent)
buf = t.serialize(bytearray(), prev)
res = struct.unpack(tcp._PACK_STR, str(buf))
eq_(res[0], self.src_port)
eq_(res[1], self.dst_port)
eq_(res[2], self.seq)
eq_(res[3], self.ack)
eq_(res[4], offset << 4)
eq_(res[5], self.bits)
eq_(res[6], self.window_size)
eq_(res[8], self.urgent)
# checksum
ph = struct.pack('!4s4sBBH',
addrconv.ipv4.text_to_bin(src_ip),
addrconv.ipv4.text_to_bin(dst_ip), 0, 6, offset * 4)
d = ph + buf + bytearray()
s = packet_utils.checksum(d)
eq_(0, s)
def _ping(self,
dp,
port_out,
ip_src=DISCOVERY_IP_SRC,
ip_dst=DISCOVERY_IP_DST,
eth_src='02:b0:00:00:00:b5',
eth_dst='02:bb:bb:bb:bb:bb',
icmp_type=8,
icmp_code=0):
ofp = dp.ofproto
parser = dp.ofproto_parser
pkt = packet.Packet()
pkt.add_protocol(
ethernet.ethernet(ethertype=0x0800, dst=eth_dst, src=eth_src))
pkt.add_protocol(ipv4.ipv4(dst=ip_dst, src=ip_src, proto=1))
pkt.add_protocol(
icmp.icmp(type_=icmp_type,
code=icmp_code,
csum=0,
data=icmp.echo(
1, 1, "{'dpid' : " + str(dp.id) + ",'port_out' : " +
str(port_out) + "}")))
pkt.serialize()
data = pkt.data
actions = [parser.OFPActionOutput(port_out, 0)]
out = parser.OFPPacketOut(datapath=dp,
buffer_id=ofp.OFP_NO_BUFFER,
in_port=ofp.OFPP_CONTROLLER,
actions=actions,
data=data)
dp.send_msg(out)
def _build_vlan(self):
src_mac = mac.haddr_to_bin('00:07:0d:af:f4:54')
dst_mac = mac.haddr_to_bin('00:00:00:00:00:00')
ethertype = ether.ETH_TYPE_8021Q
e = ethernet(dst_mac, src_mac, ethertype)
version = 4
header_length = 20
tos = 0
total_length = 24
identification = 0x8a5d
flags = 0
offset = 1480
ttl = 64
proto = inet.IPPROTO_ICMP
csum = 0xa7f2
src = int(netaddr.IPAddress('131.151.32.21'))
dst = int(netaddr.IPAddress('131.151.32.129'))
option = 'TEST'
ip = ipv4(version, header_length, tos, total_length, identification,
flags, offset, ttl, proto, csum, src, dst, option)
p = Packet()
p.add_protocol(e)
p.add_protocol(self.v)
p.add_protocol(ip)
p.serialize()
return p
def _build_itag(self):
b_src_mac = '00:07:0d:af:f4:54'
b_dst_mac = '00:00:00:00:00:00'
b_ethertype = ether.ETH_TYPE_8021AD
e1 = ethernet.ethernet(b_dst_mac, b_src_mac, b_ethertype)
b_pcp = 0
b_cfi = 0
b_vid = 32
b_ethertype = ether.ETH_TYPE_8021Q
bt = vlan.svlan(b_pcp, b_cfi, b_vid, b_ethertype)
c_src_mac = '11:11:11:11:11:11'
c_dst_mac = 'aa:aa:aa:aa:aa:aa'
c_ethertype = ether.ETH_TYPE_8021AD
e2 = ethernet.ethernet(c_dst_mac, c_src_mac, c_ethertype)
s_pcp = 0
s_cfi = 0
s_vid = 32
s_ethertype = ether.ETH_TYPE_8021Q
st = vlan.svlan(s_pcp, s_cfi, s_vid, s_ethertype)
c_pcp = 0
c_cfi = 0
c_vid = 32
c_ethertype = ether.ETH_TYPE_IP
ct = vlan.vlan(c_pcp, c_cfi, c_vid, c_ethertype)
version = 4
header_length = 20
tos = 0
total_length = 24
identification = 0x8a5d
flags = 0
offset = 1480
ttl = 64
proto = inet.IPPROTO_ICMP
csum = 0xa7f2
src = '131.151.32.21'
dst = '131.151.32.129'
option = 'TEST'
ip = ipv4.ipv4(version, header_length, tos, total_length,
identification, flags, offset, ttl, proto, csum,
src, dst, option)
p = packet.Packet()
p.add_protocol(e1)
p.add_protocol(bt)
p.add_protocol(self.it)
p.add_protocol(e2)
p.add_protocol(st)
p.add_protocol(ct)
p.add_protocol(ip)
p.serialize()
return p
def ICMPPacket(self, datapath, in_port, pkt_ethernet, pkt_ipv4, pkt_icmp):
if pkt_icmp.type == icmp.ICMP_ECHO_REQUEST:
eer=ethernet.ethernet(ethertype=pkt_ethernet.ethertype,
dst=pkt_ethernet.src,
src=self.interfaces_virtuales[self.tabla_vlan[in_port]][0])
iper=ipv4.ipv4(dst=pkt_ipv4.src,
src=self.interfaces_virtuales[self.tabla_vlan[in_port]][2],
proto=pkt_ipv4.proto)
def test_default_args(self):
prev = ipv4(proto=inet.IPPROTO_UDP)
u = udp()
buf = u.serialize(bytearray(), prev)
res = struct.unpack(udp._PACK_STR, buf)
eq_(res[0], 1)
eq_(res[1], 1)
eq_(res[2], udp._MIN_LEN)
def _handle_icmp(self, msg, pkt, icmp_pkt):
"""
reply to ICMP_ECHO_REQUEST(i.e. ping);
may handle other types of ICMP msg in the future;
return True if send a response
"""
LOG.debug('Handling ICMP packet %s', icmp_pkt)
if icmp_pkt.type != icmp.ICMP_ECHO_REQUEST:
return False
in_port_no = msg.in_port
switch = self.dpid_to_switch[msg.datapath.id]
ipv4_layer = self.find_packet(pkt, 'ipv4')
ip_src = netaddr.IPAddress(ipv4_layer.src)
ip_dst = netaddr.IPAddress(ipv4_layer.dst)
if ip_dst == netaddr.IPAddress(util.bgper_config['local_ipv4']):
self.write_to_tap(pkt.data, modifyMacAddress=True)
LOG.debug('Forward ICMP packet to tap port.')
return True
need_reply = False
for _k, p in switch.ports.iteritems():
if p.gateway and p.gateway.gw_ip == ip_dst:
need_reply = True
break
if not need_reply:
return False
echo_id = icmp_pkt.data.id
echo_seq = icmp_pkt.data.seq
echo_data = bytearray(icmp_pkt.data.data)
icmp_data = icmp.echo(id_=echo_id, seq=echo_seq, data=echo_data)
#send a echo reply packet
ether_layer = self.find_packet(pkt, 'ethernet')
ether_dst = ether_layer.src
ether_src = str(switch.ports[in_port_no].hw_addr)
e = ethernet.ethernet(ether_dst, ether_src, ether.ETH_TYPE_IP)
#csum calculation should be paid attention to
i = ipv4.ipv4(version=4, header_length=5, tos=0, total_length=0,
identification=0, flags=0x000, offset=0, ttl=64, proto=1, csum=0,
src=str(ip_dst), dst=str(ip_src), option=None)
ic = icmp.icmp(type_=0, code=0, csum=0, data=icmp_data)
p = packet.Packet()
p.add_protocol(e)
p.add_protocol(i)
p.add_protocol(ic)
p.serialize()
datapath = msg.datapath
datapath.send_packet_out(in_port=ofproto_v1_0.OFPP_NONE,
actions=[datapath.ofproto_parser.OFPActionOutput(in_port_no)],
data=p.data)
LOG.debug('Ping replied %s -> %s', ip_dst, ip_src)
return True
def packet_in_handler(self, event):
message = event.msg
datapath = message.datapath
protocol = datapath.ofproto
parser = datapath.ofproto_parser
in_port = message.match['in_port']
pkt = packet.Packet(message.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
ip4 = pkt.get_protocol(ipv4.ipv4)
dst = eth.dst
src = eth.src
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
self.mac_to_port[dpid][src] = in_port
if dst in self.mac_to_port[dpid]:
out_port = self.mac_to_port[dpid][dst]
else:
out_port = protocol.OFPP_FLOOD
if ip4 is not None:
self.logger.info("PacketIn(%s):[%s:(%s)]>>[%s:(%s)])", dpid, ip4.src, in_port, ip4.dst, out_port)
"""
todo: if ipv4.dst == 202.45.128.181: output port
"""
controlleraddress = ipv4.ipv4(dst="202.45.128.181")
if ip4 is not None:
if ip4.dst == controlleraddress.dst:
out_port = 9
# self.logger.info("202.45.128.181 address caught!")
actions = [parser.OFPActionOutput(out_port)]
if out_port != protocol.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
self.matchlist.append(match)
self.insertflow(datapath, self.table_id, 2, match, actions)
# self.logger.info("matches: %s", match)
for m in self.matchlist:
self.logger.info("matches: %s", m)
self.send_flow_stats_request(datapath, m)
data = None
if message.buffer_id == protocol.OFP_NO_BUFFER:
data = message.data
packetout = parser.OFPPacketOut(datapath=datapath,
buffer_id=message.buffer_id, in_port=in_port, actions=actions, data=data)
datapath.send_msg(packetout)
def assemble_ack(cls, pkt, datapath, port):
req_eth = pkt.get_protocol(ethernet.ethernet)
req_ipv4 = pkt.get_protocol(ipv4.ipv4)
req_udp = pkt.get_protocol(udp.udp)
req = pkt.get_protocol(dhcp.dhcp)
wanted_ip = cls.get_option_value(req, 50)
src = req_eth.src
got_ip = None
if src in cls.wan_leases[datapath]:
if wanted_ip != cls.wan_leases[datapath][src]:
cls.wan_pool.append(cls.wan_leases[datapath][src])
del cls.wan_leases[datapath][src]
else:
got_ip = cls.wan_leases[datapath][src]
if got_ip is None:
if src in cls.wan_offers[datapath]:
if wanted_ip != cls.wan_offers[datapath][src]:
cls.wan_pool.append(cls.wan_offers[datapath][src])
del cls.wan_offers[datapath][src]
else:
got_ip = cls.wan_offers[datapath][src]
if got_ip is None:
if wanted_ip in cls.wan_pool[datapath]:
cls.wan_pool[datapath].remove(wanted_ip)
got_ip = wanted_ip
if got_ip is None:
# cls.log.warn("%s asked for un-offered %s", src, wanted_ip)
# cls.nak(event) # nak
return
req.options.option_list.remove(next(opt for opt in req.options.option_list if opt.tag == 53))
req.options.option_list.insert(0, dhcp.option(tag=1, value=cls.bin_netmask))
req.options.option_list.insert(0, dhcp.option(tag=3, value=addrconv.ipv4.text_to_bin(cls.dhcp_server[datapath])))
req.options.option_list.insert(0, dhcp.option(tag=6, value=cls.bin_dns))
req.options.option_list.insert(0, dhcp.option(tag=51, value='8640'))
req.options.option_list.insert(0, dhcp.option(tag=53, value='05'.decode('hex')))
req.options.option_list.insert(0, dhcp.option(tag=54, value=addrconv.ipv4.text_to_bin(cls.dhcp_server[datapath])))
ack_pkt = packet.Packet()
ack_pkt.add_protocol(ethernet.ethernet(ethertype=req_eth.ethertype, dst=src, src=cls.hw_addr))
ack_pkt.add_protocol(ipv4.ipv4(dst=req_ipv4.dst, src=cls.dhcp_server[datapath], proto=req_ipv4.proto))
ack_pkt.add_protocol(udp.udp(src_port=67,dst_port=68))
ack_pkt.add_protocol(dhcp.dhcp(op=2, chaddr=src,
hlen=6, # salah di len
siaddr=cls.dhcp_server[datapath],
boot_file=req.boot_file,
yiaddr=wanted_ip,
xid=req.xid,
options=req.options))
# cls.logger.info("ASSEMBLED ACK: %s" % ack_pkt)
# print(wanted_ip, src, datapath, port)
cls.add_arp(wanted_ip, src, datapath, port)
return ack_pkt
def _handle_icmp(self, datapath, port, pkt_ethernet, pkt_ipv4, pkt_icmp):
if pkt_icmp.type != icmp.ICMP_ECHO_REQUEST:
return
pkt = packet.Packet()
pkt.add_protocol(ethernet.ethernet(ethertype=pkt_ethernet.ethertype, dst=pkt_ethernet.src, src=self.hw_addr))
pkt.add_protocol(ipv4.ipv4(dst=pkt_ipv4.src, src=self.ip_addr, proto=pkt_ipv4.proto))
pkt.add_protocol(
icmp.icmp(type_=icmp.ICMP_ECHO_REPLY, code=icmp.ICMP_ECHO_REPLY_CODE, csum=0, data=pkt_icmp.data)
)
self._send_packet(datapath, port, pkt)
