def test_Packet_in_3_arpReply2(self):
print "*** Case3: HOST1のMAC学習済の時、HOST2からARP Replyを受信 ***"
sr = SimpleForward()
sr.HOST_MACADDR1 = HOST_MACADDR1
sr.HOST_MACADDR2 = HOST_MACADDR2
dstMac = ROUTER_MACADDR2
srcMac = HOST_MACADDR2
srcIp = HOST_IPADDR2
dstIp = ROUTER_IPADDR2
targetMac = dstMac
targetIp = dstIp
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_ARP)
a = arp(1, 0x0800, 6, 4, 2, srcMac, srcIp, targetMac, targetIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.serialize()
packetIn = OFPPacketIn(datapath, match=OFPMatch(in_port=2), data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 0)
print ""
def receive_arp(self, datapath, packet, etherFrame, inPort):
arp_msg = packet.get_protocol(arp.arp)
if arp_msg.opcode == arp.ARP_REQUEST:
if arp_msg.dst_ip == self.ports_to_ips[inPort-1][0]:
e = ethernet.ethernet(dst=etherFrame.src,
src=self.ports_to_ips[inPort-1][2],
ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REPLY,
src_mac=self.ports_to_ips[inPort-1][2],
src_ip=arp_msg.dst_ip,
dst_mac=etherFrame.src,
dst_ip=arp_msg.src_ip)
puerto=inPort
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
self.send_packet(datapath, puerto, p)
elif arp_msg.opcode == arp.ARP_REPLY:
self.ipToMac[arp_msg.src_ip] = arp_msg.src_mac
for (msg,port,nat,puertoNat) in self.dict_pendientes[arp_msg.src_ip]:
if nat == None and puertoNat == None:
self.insertar_flujo(msg=msg, mac=arp_msg.src_mac, port=port, mod=1)
elif nat == 1:
self.insertar_flujo(msg=msg, mod=0, puerto_origen=puertoNat, ip_origen=ip_publica, sentido=1, protoc=1, port=port, mac=arp_msg.src_mac)
self.dict_pendientes[arp_msg.src_ip] = []
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match['in_port']
packets = Packet(msg.data)
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
eth = packets.get_protocols(ethernet)[0]
src = eth.src
dst = eth.dst
self.mac_to_port[dpid][src] = inPort
data = msg.data
self.arp_learning.setdefault(dpid, [])
self.packetToport.setdefault(dpid, [])
etherFrame = packets.get_protocol(ethernet)
# if dst == LLDP_MAC_NEAREST_BRIDGE:
# return
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
# print "etherFrame######", etherFrame
# etherFrame = packets.get_protocol(ethernet)
etherFrame = packets.get_protocol(ethernet)
# print etherFrame
# print ether
# print hex(etherFrame.ethertype)
# print hex(ether.ETH_TYPE_ARP)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
arpPacket = packets.get_protocol(arp)
arpArriveTime = time.time()
srcMac = etherFrame.src
arp_dstIP = arpPacket.dst_ip
self.packetToport[datapath.id] = [srcMac, arp_dstIP, inPort, arpArriveTime]
# print "arp"
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
# print "ARP: %s" % arpPacket.opcode
# # self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)
# if arpPacket.opcode == 1:
# print "ARP Requst"
# self.logger.info("packet in %s %s %s %s", datapath.id, srcMac, dst, inPort)
# elif arpPacket.opcode == 2:
# print "ARP Reply"
# self.logger.info("packet in %s %s %s %s", datapath.id, srcMac, dst, inPort)
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match['in_port']
packets = Packet(msg.data)
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
eth = packets.get_protocols(ethernet)[0]
src = eth.src
self.mac_to_port[dpid][src] = inPort
data = msg.data
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def receive_ip(self, datapath, packet, etherFrame, inPort, msg): #Función que se usa cuando se recibe un paquete IP
ipPacket = packet.get_protocol(ipv4.ipv4)
if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router
if ipPacket.proto == inet.IPPROTO_ICMP:
icmpPacket = packet.get_protocol(icmp.icmp)
self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) #Se usa una función que trata un paquete ICMP
return 0
else:
send_packet(datapath=datapath,port=inPort,packet=packet) #Se envía el paquete
return 1
else: #Si no va destinado al router
(next_hop, port) = self.find_in_routingTable(ipPacket.dst) #Almacena el puerto y el siguiente salto
#en port y en next_hop
if next_hop in self.ipToMac.keys(): #Si está dentro de la tabla de ips y macs se envía.
match = datapath.ofproto_parser.OFPMatch(eth_dst=self.ipToMac[next_hop])
actions = [datapath.ofproto_parser.OFPActionOutput(port)]
#self.add_flow(datapath, 0, match, actions)
self.insertar_flujo(msg=msg, mac=self.ipToMac[next_hop], port=port, mod=1)
else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC
# print "---- NEXT_HOP -----", next_hop
e = ethernet.ethernet(src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REQUEST,
src_ip=self.ports_to_ips[port-1][0],
src_mac=etherFrame.src,
dst_ip=next_hop)
puerto = etherFrame.src
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
if next_hop not in self.dict_pendientes:
self.dict_pendientes[next_hop] = []
self.dict_pendientes[next_hop] = self.dict_pendientes[next_hop] + [(msg, port,None,None)]
self.send_packet(datapath=datapath, port=port, packet=p)
def send_arp(self, datapath, opcode, srcMac, srcIp, dstMac, dstIp, outPort, RouteDist=None):
if opcode == 1:
self.portInfo[outPort] = PortTable(outPort, srcIp, srcMac, RouteDist)
targetMac = "00:00:00:00:00:00"
targetIp = dstIp
elif opcode == 2:
targetMac = dstMac
targetIp = dstIp
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_ARP)
a = arp(1, 0x0800, 6, 4, opcode, srcMac, srcIp, targetMac, targetIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.serialize()
actions = [datapath.ofproto_parser.OFPActionOutput(outPort, 0)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=0xffffffff,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
return 0
def find_mac(self, datapath, etherFrame, msg):
#Almacena el puerto y el siguiente salto
(next_hop, port) = self.find_in_routingTable(ipPacket.dst)
if next_hop in self.ipToMac.keys(): #Si está dentro de la tabla de ips y macs se envía.
match = datapath.ofproto_parser.OFPMatch(eth_dst=self.ipToMac[next_hop])
actions = [datapath.ofproto_parser.OFPActionOutput(port)]
self.add_flow(datapath, 0, match, actions)
self.insertar_flujo(msg=msg, mac=self.ipToMac[next_hop], port=port, mod=1)
else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC
# print "---- NEXT_HOP -----", next_hop
e = ethernet.ethernet(src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REQUEST,
src_ip=self.ports_to_ips[port-1][0],
src_mac=etherFrame.src,
dst_ip=next_hop)
puerto = etherFrame.src
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
if next_hop not in self.dict_pendientes:
self.dict_pendientes[next_hop] = []
self.dict_pendientes[next_hop] = self.dict_pendientes[next_hop] + [(msg, port, None, None)]
self.send_packet(datapath=datapath, port=port, packet=p)
def send_icmp(self,
datapath,
srcMac,
srcIp,
dstMac,
dstIp,
outPort,
seq,
data,
id=1,
type=8,
ttl=64):
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_IP)
iph = ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp)
echo = icmp.echo(id, seq, data)
icmph = icmp.icmp(type, 0, 0, echo)
p = Packet()
p.add_protocol(e)
p.add_protocol(iph)
p.add_protocol(icmph)
p.serialize()
actions = [datapath.ofproto_parser.OFPActionOutput(outPort, 0)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=0xffffffff,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
return 0
def packet_in_handler(self, ev):
msg = ev.msg
pkt = Packet(msg.data)
dp = msg.datapath
in_port = msg.match['in_port']
ofp = dp.ofproto
ofp_parser = dp.ofproto_parser
#pdb.set_trace()
actions = []
#dp.send_msg(out)
ip = pkt.get_protocol(ipv4.ipv4)
print ip
if ip:
print ip
#actions.append(ofp.OFPActionDecNwTtl())
actions.append(ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD))
out = ofp_parser.OFPPacketOut(
datapath=dp, buffer_id=msg.buffer_id, in_port=in_port,
actions=actions)
dp.send_msg(out)
def test_Packet_in_2_icmpEcho1(self):
print "*** Case2: HOST2のMAC未学習の時、HOST1からICMP Echoを受信 ***"
sr = SimpleForward()
dstMac = ROUTER_MACADDR1
srcMac = HOST_MACADDR1
srcIp = HOST_IPADDR1
dstIp = HOST_IPADDR2
targetMac = dstMac
targetIp = dstIp
ttl = 64
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_IP)
iph = ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp)
echo = icmp.echo(1, 1, 'unit test')
icmph = icmp.icmp(8, 0, 0, echo)
p = Packet()
p.add_protocol(e)
p.add_protocol(iph)
p.add_protocol(icmph)
p.serialize()
packetIn = OFPPacketIn(datapath,
match=OFPMatch(in_port=1),
data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 1)
print ""
def packetIn_handler(self,event):
msg = event.msg
data = msg.data
datapath = msg.datapath
dapid = datapath.id
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = Packet(data)
eth = pkt.get_protocol(ethernet)
eth_src = eth.src
eth_dst = eth.dst
self.mac_to_port.setdefault(datapath.id,{})
self.mac_to_port[datapath.id].setdefault(eth_src,in_port)
#self.mac_to_port[datapath.id][eth_src] = in_port
allPkts = dict((p.protocol_name,p) for p in pkt.protocols)
print("packet in %s %s"%(str(eth_src),str(eth_dst)))
if eth_dst in self.mac_to_port[datapath.id]:
out_port = self.mac_to_port[datapath.id][eth_dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
pktout_msg = parser.OFPPacketOut(datapath=datapath,buffer_id=ofproto.OFP_NO_BUFFER,
in_port=in_port,actions=actions,data=msg.data)
datapath.send_msg(pktout_msg)
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match['in_port']
packets = Packet(msg.data)
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
eth = packets.get_protocols(ethernet)[0]
src = eth.src
self.mac_to_port[dpid][src] = inPort
data = msg.data
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
# print "packets: ", packets
# print "packets.get_protocols(ethernet): ", packets.get_protocols(ethernet)
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def test_Packet_in_1_arpRequest(self):
print "*** Case1: HOST1からARP Request受信 ***"
sr = SimpleForward()
dstMac = "ff:ff:ff:ff:ff:ff"
srcMac = HOST_MACADDR1
srcIp = HOST_IPADDR1
dstIp = ROUTER_IPADDR1
targetMac = dstMac
targetIp = dstIp
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_ARP)
a = arp(1, 0x0800, 6, 4, 1, srcMac, srcIp, targetMac, targetIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.serialize()
packetIn = OFPPacketIn(datapath, match=OFPMatch(in_port=1), data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 0)
print ""
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 arp_response(self, datapath, pkt, ether_frame, ofp_parser, ofp,
in_port):
arp_packet = pkt.get_protocol(arp.arp)
dst_ip = arp_packet.src_ip
src_ip = arp_packet.dst_ip
dst_mac = ether_frame.src
# If the ARP request isn't from one of the two servers,
# choose the target/source MAC address from one of the servers;
# else the target MAC address is set to the one corresponding
# to the target host's IP.
if dst_ip != self.H1_ip and dst_ip != self.H2_ip:
src_mac = self.VIRTUAL_MAC
# if self.next_server == self.H1_ip:
# src_mac = self.H1_mac
# self.next_server = self.H2_ip
# else:
# src_mac = self.H2_mac
# self.next_server = self.H1_ip
else:
src_mac = self.ip_to_mac[src_ip]
print "arp_response -> src_mac : %s" % src_mac
eth_header = ethernet.ethernet(dst_mac, src_mac,
ether_types.ETH_TYPE_ARP)
arp_reply_packet = arp.arp(hwtype=ARP_HW_TYPE_ETHERNET,
proto=ETH_TYPE_IP,
hlen=6,
plen=4,
opcode=ARP_REPLY,
src_mac=src_mac,
src_ip=src_ip,
dst_mac=dst_mac,
dst_ip=dst_ip)
print "arp_response -> src_mac : %s" % src_mac
print "arp_response -> src_ip : %s" % src_ip
print "arp_response -> dst_mac : %s" % dst_mac
print "arp_response -> dst_ip : %s" % dst_ip
pkt = Packet(protocols=[eth_header, arp_reply_packet])
pkt.serialize()
# ARP action list
actions = [ofp_parser.OFPActionOutput(ofp.OFPP_IN_PORT)]
# ARP output message
out = ofp_parser.OFPPacketOut(datapath=datapath,
buffer_id=ofp.OFP_NO_BUFFER,
in_port=in_port,
actions=actions,
data=pkt.data)
datapath.send_msg(out) # Send out ARP reply
def receive_ip(self, datapath, packet, etherFrame, inPort,
msg): #Función que se usa cuando se recibe un paquete IP
ipPacket = packet.get_protocol(ipv4.ipv4)
#print packet.get_protocol(ipv4.ipv4)
print "LLEGÓ UN PAQUETE IP"
if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router
print "VA DESTINADO AL ROUTER"
if ipPacket.proto == inet.IPPROTO_ICMP:
print "Y ES ICMP"
icmpPacket = packet.get_protocol(icmp.icmp)
self.check_icmp(
datapath, etherFrame, ipPacket, icmpPacket,
inPort) #Se usa una función que trata un paquete ICMP
return 0
else:
send_packet(datapath=datapath, port=inPort,
packet=packet) #Se envía el paquete
return 1
else: #Si no va destinado al router
print "NO VA DESTINADO AL ROUTER"
(next_hop, port) = self.find_in_routingTable(
ipPacket.dst) #Almacena el puerto y el siguiente salto
#en port y en next_hop
print "¿Está dentro de la tabla ", next_hop, " ?"
if next_hop in self.ipToMac.keys(
): #Si está dentro de la tabla de ips y macs se envía.
print "ESTÁ DENTRO DE LA TABLA##################################################"
print "ipToMac[next_hop] = ", self.ipToMac[next_hop]
match = datapath.ofproto_parser.OFPMatch(
eth_dst=self.ipToMac[next_hop])
actions = [datapath.ofproto_parser.OFPActionOutput(port)]
self.add_flow(datapath, 0, match, actions)
self.insertar_flujo(msg, self.ipToMac[next_hop], port)
else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC
print "NO ESTÁ DENTRO DE LA TABLA"
print "---- NEXT_HOP -----", next_hop
e = ethernet.ethernet( #dst=etherFrame.dst,
src=etherFrame.dst,
ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REQUEST,
src_ip=self.ports_to_ips[port - 1][0],
src_mac=etherFrame.src,
dst_ip=next_hop)
puerto = etherFrame.src
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
if next_hop not in self.dict_pendientes:
self.dict_pendientes[next_hop] = []
self.dict_pendientes[
next_hop] = self.dict_pendientes[next_hop] + [(msg, port)]
#def send_packet(self, datapath, port, packet):
print "llegó por el PUERTO: ", inPort, "Sale por el puerto: ", port
self.send_packet(datapath=datapath, port=port, packet=p)
def packet_in_handler(self, ev):
msg = ev.msg
pkt = Packet(msg.data)
dp = msg.datapath
#self._request_stats(dp)
in_port = msg.match['in_port']
#self._request_stats(dp)
ofp = dp.ofproto
ofp_parser = dp.ofproto_parser
#pdb.set_trace()
actions = []
#dp.send_msg(out)
ip = pkt.get_protocol(ipv4.ipv4)
pk_tcp = pkt.get_protocol(tcp.tcp)
#self.total = self.total + pk_tcp.window_size
actions.append(ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD))
out = ofp_parser.OFPPacketOut(
datapath=dp, buffer_id=msg.buffer_id, in_port=in_port,
actions=actions)
dp.send_msg(out)
op = randint(0,1)
if ip:
#print ip
ip.ttl = op
#print ip
#actions.append(ofp.OFPActionDecNwTtl())
if ip.ttl == 1:
self.tabelaPacotesGrandes.append(ip)
self.total = self.total + ip.total_length
print "----------------------------------TTL COM 1----------------------------------"
else:
self.tabelaPacotesPequenos.append(ip)
self.total = self.total + ip.total_length
print "----------------------------------TTL COM 0----------------------------------"
self._send_packet(dp, in_port, pkt)
def _packet_in_handler(self, ev):
"""Handle packet_in events."""
if not self.link_discovery:
return
msg = ev.msg
in_port = msg.match['in_port']
packet = Packet(msg.data)
efm = packet.next()
if efm.ethertype == ether.ETH_TYPE_ARP:
self.send_event_to_observers(event.EventArpReceived(ev))
try:
src_dpid, src_port_no = LLDPPacket.lldp_parse(msg.data)
except LLDPPacket.LLDPUnknownFormat as e:
# This handler can receive all the packtes which can be
# not-LLDP packet. Ignore it silently
return
else:
dst_dpid = msg.datapath.id
dst_port_no = in_port
src = self._get_port(src_dpid, src_port_no)
if not src or src.dpid == dst_dpid:
return
dst = self._get_port(dst_dpid, dst_port_no)
if not dst:
return
old_peer = self.links.get_peer(src)
#LOG.debug("Packet-In")
#LOG.debug(" src=%s", src)
#LOG.debug(" dst=%s", dst)
#LOG.debug(" old_peer=%s", old_peer)
if old_peer and old_peer != dst:
old_link = Link(src, old_peer)
self.send_event_to_observers(event.EventLinkDelete(old_link))
link = Link(src, dst)
if not link in self.links:
self.send_event_to_observers(event.EventLinkAdd(link))
if not self.links.update_link(src, dst):
# reverse link is not detected yet.
# So schedule the check early because it's very likely it's up
try:
self.ports.lldp_received(dst)
except KeyError as e:
# There are races between EventOFPPacketIn and
# EventDPPortAdd. So packet-in event can happend before
# port add event. In that case key error can happend.
# LOG.debug('lldp_received: KeyError %s', e)
pass
else:
self.ports.move_front(dst)
self.lldp_event.set()
def _packet_in_handler(self, ev):
"""Handle packet_in events."""
if not self.link_discovery:
return
msg = ev.msg
in_port = msg.match['in_port']
packet = Packet(msg.data)
efm = packet.get_protocol(ethernet.ethernet)
if efm.ethertype == ether.ETH_TYPE_ARP:
self.send_event_to_observers(event.EventArpReceived(ev))
try:
src_dpid, src_port_no = LLDPPacket.lldp_parse(msg.data)
except LLDPPacket.LLDPUnknownFormat as e:
# This handler can receive all the packtes which can be
# not-LLDP packet. Ignore it silently
return
else:
dst_dpid = msg.datapath.id
dst_port_no = in_port
src = self._get_port(src_dpid, src_port_no)
if not src or src.dpid == dst_dpid:
return
dst = self._get_port(dst_dpid, dst_port_no)
if not dst:
return
old_peer = self.links.get_peer(src)
#LOG.debug("Packet-In")
#LOG.debug(" src=%s", src)
#LOG.debug(" dst=%s", dst)
#LOG.debug(" old_peer=%s", old_peer)
if old_peer and old_peer != dst:
old_link = Link(src, old_peer)
self.send_event_to_observers(event.EventLinkDelete(old_link))
link = Link(src, dst)
if not link in self.links:
self.send_event_to_observers(event.EventLinkAdd(link))
if not self.links.update_link(src, dst):
# reverse link is not detected yet.
# So schedule the check early because it's very likely it's up
try:
self.ports.lldp_received(dst)
except KeyError as e:
# There are races between EventOFPPacketIn and
# EventDPPortAdd. So packet-in event can happend before
# port add event. In that case key error can happend.
# LOG.debug('lldp_received: KeyError %s', e)
pass
else:
self.ports.move_front(dst)
self.lldp_event.set()
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 test_Packet_in_2_icmpEcho1(self):
print "*** Case2: HOST2のMAC未学習の時、HOST1からICMP Echoを受信 ***"
sr = SimpleForward()
dstMac = ROUTER_MACADDR1
srcMac = HOST_MACADDR1
srcIp = HOST_IPADDR1
dstIp = HOST_IPADDR2
targetMac = dstMac
targetIp = dstIp
ttl = 64
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_IP)
iph = ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp)
echo = icmp.echo(1, 1, 'unit test')
icmph = icmp.icmp(8, 0, 0, echo)
p = Packet()
p.add_protocol(e)
p.add_protocol(iph)
p.add_protocol(icmph)
p.serialize()
packetIn = OFPPacketIn(datapath, match=OFPMatch(in_port=1), data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 1)
print ""
def enviar_arp(self, mac_origen, port, next_hop, datapath, msg, nat=None, puertoNat=None):
e = ethernet.ethernet(src=mac_origen, ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REQUEST,
src_ip=self.ports_to_ips[port-1][0],
src_mac=mac_origen,
dst_ip=next_hop)
#puerto = mac_origen
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
self.insertar_en_cola(ip=next_hop, puerto=port, msg=msg, nat=nat, puertoNat=puertoNat)
self.send_packet(datapath=datapath, port=port, packet=p)
def receive_icmp(self, datapath, packet, port):
ip_packet = packet.get_protocol(ipv4.ipv4)
icmp_packet = packet.get_protocol(icmp.icmp)
if icmp_packet.type == 8: # Echo request
dst_mac = self.arpcache.get_mac(ip_packet.src, port)
ip_data = self.ports.get_ip(ip_packet.dst)
if (ip_data == None):
LOG.debug("ICMP not for router")
return 0
(ip_addr,mask,mac_addr) = self.ports.get_port(port) # Routing
e = ethernet.ethernet(dst_mac, mac_addr, ether.ETH_TYPE_IP)
ip = ipv4.ipv4(src= ip_packet.dst, dst=ip_packet.src, proto= inet.IPPROTO_ICMP,ttl=64)
echo_new = icmp.echo(icmp_packet.data.id, icmp_packet.data.seq, icmp_packet.data.data)
icmp_new = icmp.icmp(type_=0, code=0, data=echo_new)
p = Packet()
p.add_protocol(e)
p.add_protocol(ip)
p.add_protocol(icmp_new)
self.send_packet(datapath,port, p)
LOG.debug("ICMP for router")
return 1
return 0
def _packet_in_handler(self, ev):
#LOG.debug("received packet!!")
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = Packet(msg.data)
eth_frame = pkt.get_protocol(ethernet)
if eth_frame.ethertype == ether.ETH_TYPE_ARP:
self.handle_arp(datapath, in_port, eth_frame, pkt)
def test_Packet_in_4_icmpEcho2(self):
print "*** Case4: HOST2からHOST1以外の宛先IPへのIPパケットを受信 ***"
sr = SimpleForward()
sr.HOST_MACADDR1 = HOST_MACADDR1
sr.HOST_MACADDR2 = HOST_MACADDR2
dstMac = ROUTER_MACADDR2
srcMac = HOST_MACADDR2
srcIp = HOST_IPADDR2
dstIp = "91.189.89.22"
ttl = 64
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_IP)
iph = ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(iph)
p.serialize()
packetIn = OFPPacketIn(datapath,
match=OFPMatch(in_port=2),
data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 1)
print ""
def send_icmp(self, datapath, etherFrame, ipPacket, icmpPacket, inPort):
e = ethernet(dst=etherFrame.src,
src=etherFrame.dst,
ethertype=ether.ETH_TYPE_IP)
a = ipv4(version=ipPacket.version,
header_length=ipPacket.header_length,
tos=ipPacket.tos,
total_length=ipPacket.total_length,
identification=ipPacket.identification,
flags=ipPacket.flags,
offset=ipPacket.offset,
ttl=ipPacket.ttl,
proto=ipPacket.proto,
csum=ipPacket.csum,
src=ipPacket.dst,
dst=ipPacket.src,
option=None)
b = icmp(type_=ICMP_ECHO_REPLY,
code=icmpPacket.code,
csum=icmpPacket.csum,
data=icmpPacket.data)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.add_protocol(b)
p.serialize()
actions = [datapath.ofproto_parser.OFPActionOutput(inPort, 0)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=0xffffffff,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
def handle_ipv4(self, packet_in: ofproto_v1_0_parser.OFPPacketIn,
frame: packet.Packet, eth_header: ethernet.ethernet,
ipv4_header: ipv4.ipv4):
self.logger.info(" %s -> %s, proto=0x%x (%s)", ipv4_header.src,
ipv4_header.dst, ipv4_header.proto,
ip_proto_name(ipv4_header.proto))
datapath_id = packet_in.datapath.id
self.ip_to_port.setdefault(datapath_id,
{})[ipv4_header.src] = packet_in.in_port
if ipv4_header.proto == inet.IPPROTO_TCP:
tcp_header = frame.get_protocol(tcp.tcp)
self.handle_tcp(packet_in, eth_header, ipv4_header, tcp_header)
elif ipv4_header.proto == inet.IPPROTO_ICMP:
icmp_header = frame.get_protocol(icmp.icmp)
self.handle_icmp(packet_in, eth_header, ipv4_header, icmp_header)
def _build_arp(self, vlan_enabled):
if vlan_enabled is True:
ethertype = ether.ETH_TYPE_8021Q
v = vlan(1, 1, 3, ether.ETH_TYPE_ARP)
else:
ethertype = ether.ETH_TYPE_ARP
e = ethernet(self.dst_mac, self.src_mac, ethertype)
p = Packet()
p.add_protocol(e)
if vlan_enabled is True:
p.add_protocol(v)
p.add_protocol(self.a)
p.serialize()
return p
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
in_port = msg.match['in_port']
packet = Packet(msg.data)
ether_frame = packet.get_protocol(ethernet)
if ether_frame.ethertype == ether.ETH_TYPE_ARP:
self.receive_arp(datapath, packet, ether_frame)
return 0
elif ether_frame.ethertype == ether.ETH_TYPE_IP:
self.receive_ip(datapath, packet, in_port)
return 1
else:
return 2
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
pkt = Packet(msg.data)
pkt_udp = pkt.get_protocol(udp.udp)
pkt_tcp = pkt.get_protocol(tcp.tcp)
header_list = dict((p.protocol_name, p)
for p in pkt.protocols if type(p) != str)
self.logger.info(header_list)
if pkt_udp:
src_port = pkt_udp.src_port
dst_port = pkt_udp.dst_port
elif pkt_tcp:
src_port = pkt_tcp.src_port
dst_port = pkt_tcp.dst_port
for ipproto in [6,17]:
mod_flow_entry(datapath,
{'priority' : 100,
'table_id' : 0,
'match' : {'tp_src': src_port,
'dl_type': 2048,
'ip_proto': ipproto},
'actions' :[{'type': 'WRITE_METADATA',
'metadata': src_port << 16,
'metadata_mask' : 4294901760},
{'type': 'GOTO_TABLE',
'table_id' : 1}]},
ofproto.OFPFC_ADD)
mod_flow_entry(datapath,
{'priority' : 100,
'table_id' : 1,
'match' : {'tp_dst': dst_port,
'dl_type': 2048,
'ip_proto': ipproto},
'actions' :[{'type': 'WRITE_METADATA',
'metadata': dst_port,
'metadata_mask': 65535},
{'type' : 'GOTO_TABLE',
'table_id' : 2}]},
ofproto.OFPFC_ADD)
self.packet_out(datapath, pkt)
def test_20_check_withdrawal_2(self):
g1 = self.gobgp
g2 = self.quaggas['g2']
dumpfile = g2.start_tcpdump()
g1.add_route('10.40.0.0/24')
time.sleep(1)
paths = g2.get_global_rib('10.40.0.0/24')
self.assertTrue(len(paths) == 1)
g1.local('gobgp global rib del 10.40.0.0/24')
time.sleep(1)
paths = g2.get_global_rib('10.40.0.0/24')
self.assertTrue(len(paths) == 0)
g2.stop_tcpdump()
time.sleep(1)
cnt = 0
for _, buf in pcap.Reader(open(dumpfile)):
pkt = Packet(buf).get_protocol(BGPMessage)
if isinstance(pkt, BGPUpdate):
cnt += len(pkt.withdrawn_routes)
self.assertTrue(cnt == 1)
def test_20_check_withdrawal_2(self):
g1 = self.gobgp
g2 = self.quaggas['g2']
dumpfile = g2.start_tcpdump()
g1.add_route('10.40.0.0/24')
time.sleep(1)
paths = g2.get_global_rib('10.40.0.0/24')
self.assertTrue(len(paths) == 1)
g1.local('gobgp global rib del 10.40.0.0/24')
time.sleep(1)
paths = g2.get_global_rib('10.40.0.0/24')
self.assertTrue(len(paths) == 0)
g2.stop_tcpdump()
time.sleep(1)
cnt = 0
for pkt in pcap.Reader(open(dumpfile)):
last = Packet(pkt[1]).protocols[-1]
if type(last) == str:
pkt = BGPMessage.parser(last)[0]
if type(pkt) == BGPUpdate:
cnt += len(pkt.withdrawn_routes)
self.assertTrue(cnt == 1)
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
inPort = msg.match['in_port']
packet = Packet(msg.data)
etherFrame = packet.get_protocol(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
arpPacket = packet.get_protocol(arp)
if arpPacket.dst_ip != OUTER_IPADDR and arpPacket.dst_ip != INNER_IPADDR:
LOG.debug("Miss: This ARP packet is not for me.")
return 1
arpPacket = packet.get_protocol(arp)
self.receive_arp(datapath, packet, etherFrame, inPort)
return 0
elif etherFrame.ethertype == ether.ETH_TYPE_IP:
ipPacket = packet.get_protocol(ipv4)
if ipPacket.dst != OUTER_IPADDR:
LOG.debug("Miss: This IP packet is not for me.")
return 1
self.receive_ip(datapath, packet, etherFrame, inPort)
return 1
else:
LOG.debug("receive Unknown packet %s => %s (port%d)"
% (etherFrame.src, etherFrame.dst, inPort))
self.print_etherFrame(etherFrame)
LOG.debug("Drop packet")
return 2
def _send_packet(self, ev):
"""
First install drop flows if they are not there yet.
Then send the packet through the switch
:param ev: EventSendPacket
"""
self.install_drop_flows()
pkt = ev.packet
imsi = ev.imsi
if isinstance(pkt, (bytes, bytearray)):
data = bytearray(pkt)
elif isinstance(pkt, Packet):
pkt.serialize()
data = pkt.data
else:
raise ValueError('Could not handle packet of type: '
'{}'.format(type(pkt)))
self.logger.debug('Tracer sending packet: %s', str(Packet(data)))
datapath = get_datapath(self, dpid=self._datapath.id)
ofp = datapath.ofproto
ofp_parser = datapath.ofproto_parser
actions = [
# Turn on test-packet as we're just tracing it
ofp_parser.NXActionRegLoad2(dst=TEST_PACKET_REG,
value=TestPacket.ON.value),
# Add IMSI metadata
ofp_parser.NXActionRegLoad2(dst=IMSI_REG, value=encode_imsi(imsi)),
# Submit to table=0 because otherwise the packet will be dropped!
ofp_parser.NXActionResubmitTable(table_id=0),
]
datapath.send_packet_out(in_port=ofp.OFPP_LOCAL,
actions=actions,
data=data)
def packet_in_handler(self, ev):
"""
Routing simplified for prototyping!!!
Only works with Topology of testbed0/mininet_multi_switches_ipv4.py
:param ev:
:return:
"""
msg = ev.msg
datapath = msg.datapath
inPort = msg.match['in_port']
packet = Packet(msg.data)
etherFrame = packet.get_protocol(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_LLDP:
# ignore lldp packet
return
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
self.receive_arp(datapath, packet, etherFrame, inPort)
elif etherFrame.ethertype == ether.ETH_TYPE_IP:
self.receive_ip(datapath, packet, etherFrame, inPort)
else:
LOG.debug("receive Unknown packet %s => %s (port%d)"
% (etherFrame.src, etherFrame.dst, inPort))
self.print_etherFrame(etherFrame)
LOG.debug("Drop packet")
return 1
return 0
def packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
inPort = msg.match['in_port']
dpid = datapath.id
self.ip_to_mac.setdefault(dpid, {})
packet = Packet(msg.data)
etherFrame = packet.get_protocol(ethernet)
srcMAC = etherFrame.src
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
self.receive_arp(datapath, packet, etherFrame, inPort)
return 0
elif etherFrame.ethertype == ether.ETH_TYPE_IP:
ipPacket = packet.get_protocol(ipv4)
srcIp = ipPacket.src
if (ipPacket.proto == IPPROTO_ICMP) & (self.ip_to_mac[dpid][srcIp]
== srcMAC):
self.receive_icmp(datapath, packet, etherFrame, inPort)
return 0
elif (ipPacket.proto == IPPROTO_ICMP):
self.send_arp(datapath, ARP_REQUEST, ROUTER_MACADDR1,
ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", srcIp,
inPort)
else:
LOG.debug("Drop packet")
return 1
def trace_packet(self, packet, imsi, timeout=2):
"""
Send a packet and wait until it is processed and the dropped_table dict
shows which table caused a drop.
Important: trace_packet initiates a packet-send through
self.send_event_to_observers() because trace_packet could be called
from a different thread than the one Ryu app is running on, which will
cause the datapath to reconnect. To avoid that we initiate an
EventSendPacket which will be handled on the Ryu event-loop thread.
:param packet: bytes of the packet
:param imsi: IMSI string (like 001010000000013 or IMSI001010000000013)
:param timeout: timeout after which to stop waiting for a packet
:return: table_id which caused the drop or -1 if it wasn't dropped
"""
assert isinstance(packet, bytes)
self.logger.debug('Trace packet: %s', str(Packet(packet)))
self.send_event_to_observers(EventSendPacket(pkt=packet, imsi=imsi))
start = time.time()
while packet not in self.dropped_table:
if time.time() > start + timeout:
raise Exception('Timeout while waiting for the packet')
time.sleep(0.1)
table_id = self.dropped_table[packet]
del self.dropped_table[packet]
# If the table was returned to the user space after the last table =>
# It wasn't dropped in the process
if table_id == self._service_manager.get_table_num(EGRESS):
return -1
return table_id
def send_icmp(self, datapath, srcMac, srcIp, dstMac, dstIp, outPort, seq, data, id=1, type=8, ttl=64):
e = ethernet.ethernet(dstMac, srcMac, ether.ETH_TYPE_IP) #Construye el protocolo ethernet
iph = ipv4.ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp) #Construye la parte del protocolo IP
echo = icmp.echo(id, seq, data) #Construye la parte del echo que se añadirá al protocolo icmp
icmph = icmp.icmp(type, 0, 0, echo) #Construye la parte del icmp
p = Packet() #Crea el paquete
p.add_protocol(e) #Añade el protocolo ethernet
p.add_protocol(iph) #Añade el protocolo ip
p.add_protocol(icmph) #Añade el protocolo icmp
p.serialize() #Serializa todo
actions = [datapath.ofproto_parser.OFPActionOutput(outPort, 0)] #Enviar por el puerto outPort
#Mensaje a enviar
out = datapath.ofproto_parser.OFPPacketOut(datapath=datapath, buffer_id=0xffffffff, in_port=datapath.ofproto.OFPP_CONTROLLER, actions=actions, data=p.data)
datapath.send_msg(out) #Enviar mensaje
def packet_in_handler(self,
ev): #Qué hace el router cuando le llegua un paquete
#print('ENTRO EN LA RUTINA')
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
in_port = msg.match['in_port']
packet = Packet(msg.data)
eth = packet.get_protocol(ethernet.ethernet)
ethertype = packet.get_protocol(ethernet.ethernet)
print "PAQUETE: \n", packet
src = eth.src
#print(src)
dst = eth.dst
#sdgsa
self.mac_to_port[src] = in_port
#print(1)
if eth.ethertype == ether.ETH_TYPE_ARP: #Si se trata de un paquete ARPÇ
self.receive_arp(datapath, packet, ethertype, in_port)
elif eth.ethertype == ether.ETH_TYPE_IP: #Si se trata de un paquete IP
#print('paquete ip')
self.receive_ip(datapath, packet, ethertype, in_port, msg)
def receive_ip(self, datapath, packet, etherFrame, inPort, msg): #Función que se usa cuando se recibe un paquete IP
ipPacket = packet.get_protocol(ipv4.ipv4)
#print packet.get_protocol(ipv4.ipv4)
print "LLEGÓ UN PAQUETE IP"
if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router
print "VA DESTINADO AL ROUTER"
if ipPacket.proto == inet.IPPROTO_ICMP:
print "Y ES ICMP"
icmpPacket = packet.get_protocol(icmp.icmp)
self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) #Se usa una función que trata un paquete ICMP
return 0
else:
send_packet(datapath=datapath,port=inPort,packet=packet) #Se envía el paquete
return 1
else: #Si no va destinado al router
print "NO VA DESTINADO AL ROUTER"
(next_hop, port) = self.find_in_routingTable(ipPacket.dst) #Almacena el puerto y el siguiente salto
#en port y en next_hop
print "¿Está dentro de la tabla ", next_hop, " ?"
if next_hop in self.ipToMac.keys(): #Si está dentro de la tabla de ips y macs se envía.
print "ESTÁ DENTRO DE LA TABLA##################################################"
print "ipToMac[next_hop] = ", self.ipToMac[next_hop]
match = datapath.ofproto_parser.OFPMatch(eth_dst=self.ipToMac[next_hop])
actions = [datapath.ofproto_parser.OFPActionOutput(port)]
self.add_flow(datapath, 0, match, actions)
self.insertar_flujo(msg, self.ipToMac[next_hop], port)
else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC
print "NO ESTÁ DENTRO DE LA TABLA"
print "---- NEXT_HOP -----", next_hop
e = ethernet.ethernet(#dst=etherFrame.dst,
src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP)
a = arp.arp(opcode=arp.ARP_REQUEST,
src_ip=self.ports_to_ips[port-1][0],
src_mac=etherFrame.src,
dst_ip=next_hop)
puerto = etherFrame.src
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
if next_hop not in self.dict_pendientes:
self.dict_pendientes[next_hop] = []
self.dict_pendientes[next_hop] = self.dict_pendientes[next_hop] + [(msg, port)]
#def send_packet(self, datapath, port, packet):
print "llegó por el PUERTO: ", inPort, "Sale por el puerto: ", port
self.send_packet(datapath=datapath, port=port, packet=p)
def test_Packet_in(self):
sa = SimpleArp()
datapath = _Datapath()
e = ethernet.ethernet(dstMac, srcMac, ether.ETH_TYPE_ARP)
a = arp(1, 0x0800, 6, 4, 1, srcMac, srcIp, targetMac, dstIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.serialize()
packetIn = OFPPacketIn(datapath, match=OFPMatch(in_port=1), data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sa.packet_in_handler(ev)
self.assertEqual(result, 0)
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match['in_port']
packets = Packet(msg.data)
dpid = datapath.id
eth = packets.get_protocols(ethernet)[0]
src = eth.src
dst = eth.dst
self.mac_to_port.setdefault(hex(dpid), {})
self.arp_learning.setdefault(dpid, [])
self.packetToport.setdefault(dpid, {})
if dst == LLDP_MAC_NEAREST_BRIDGE:
return
if src in self.mac_to_port[hex(dpid)].keys():
pass
else:
self.mac_to_port[hex(dpid)][src] = inPort
data = msg.data
etherFrame = packets.get_protocol(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
self.logger.debug("\n:")
# arpPacket = packets.get_protocol(arp)
# arpArriveTime = time.time()
# srcMac = etherFrame.src
# arp_dstIP = arpPacket.dst_ip
dst = eth.dst
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes",
ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match['in_port']
packets = Packet(msg.data)
dpid = datapath.id
eth = packets.get_protocols(ethernet)[0]
src = eth.src
dst = eth.dst
self.mac_to_port.setdefault(hex(dpid), {})
self.arp_learning.setdefault(dpid, [])
self.packetToport.setdefault(dpid, {})
if dst == LLDP_MAC_NEAREST_BRIDGE:
return
if src in self.mac_to_port[hex(dpid)].keys():
pass
else:
self.mac_to_port[hex(dpid)][src] = inPort
data = msg.data
# print mac_to_port for verification
# self.logger.info("MySimpleArp: self.mac_to_port")
# for key, value in self.mac_to_port.items():
# print "\t", self._hostname_Check(int(str(key), 16)), value
etherFrame = packets.get_protocol(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
self.logger.debug("\n:")
dst = eth.dst
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def reply_arp(self, datapath, frame, packet, ip, port):
(ip_addr, mask, mac_addr)=self.ports.get_port(int(port))
LOG.debug("ARP reply: %s %s, ip: %s, port=%d" % (ip_addr, mac_addr, ip, port))
LOG.debug("Router %s: %s" % (self.name, self.ports.ports))
if (ip == ip_addr): # Only generates a reply if the request is for router
arp_packet = packet.get_protocol(arp.arp)
target_ip = arp_packet.src_ip
target_mac = arp_packet.src_mac
e = ethernet.ethernet(target_mac, mac_addr, ether.ETH_TYPE_ARP)
a = arp.arp(1, 0x0800, 6, 4, 2, mac_addr, ip_addr, target_mac, target_ip)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
self.send_packet(datapath,port,p)
def send_icmp(self, datapath, etherFrame,ipPacket, icmpPacket,inPort):
e = ethernet(dst=etherFrame.src ,
src=etherFrame.dst,
ethertype=ether.ETH_TYPE_IP)
a = ipv4(version=ipPacket.version, header_length=ipPacket.header_length, tos=ipPacket.tos,
total_length=ipPacket.total_length, identification=ipPacket.identification, flags=ipPacket.flags,
offset=ipPacket.offset, ttl=ipPacket.ttl, proto=ipPacket.proto, csum=ipPacket.csum,
src=ipPacket.dst,
dst= ipPacket.src,
option=None)
b = icmp( type_=ICMP_ECHO_REPLY, code=icmpPacket.code, csum=icmpPacket.csum, data=icmpPacket.data)
p = Packet()
p.add_protocol(e)
p.add_protocol(a)
p.add_protocol(b)
p.serialize()
actions = [datapath.ofproto_parser.OFPActionOutput(inPort, 0)]
out = datapath.ofproto_parser.OFPPacketOut(
datapath=datapath,
buffer_id=0xffffffff,
in_port=datapath.ofproto.OFPP_CONTROLLER,
actions=actions,
data=p.data)
datapath.send_msg(out)
def _packet_in_handler(self, ev):
self.logger.debug("my_arp: _packet_in_handler:")
# If you hit this you might want to increase
# the "miss_send_length" of your switch
if ev.msg.msg_len < ev.msg.total_len:
self.logger.debug("packet truncated: only %s of %s bytes", ev.msg.msg_len, ev.msg.total_len)
msg = ev.msg
datapath = msg.datapath
# ofproto = datapath.ofproto
inPort = msg.match["in_port"]
packets = Packet(msg.data)
dpid = datapath.id
eth = packets.get_protocols(ethernet)[0]
src = eth.src
dst = eth.dst
self.mac_to_port.setdefault(hex(dpid), {})
self.arp_learning.setdefault(dpid, [])
self.packetToport.setdefault(dpid, {})
if dst == LLDP_MAC_NEAREST_BRIDGE:
return
if src in self.mac_to_port[hex(dpid)].keys():
pass
else:
self.mac_to_port[hex(dpid)][src] = inPort
data = msg.data
etherFrame = packets.get_protocol(ethernet)
if etherFrame.ethertype == ether.ETH_TYPE_ARP:
self.logger.debug("\n:")
# arpPacket = packets.get_protocol(arp)
# arpArriveTime = time.time()
# srcMac = etherFrame.src
# arp_dstIP = arpPacket.dst_ip
dst = eth.dst
self.receive_arp(datapath, packets, etherFrame, inPort, data)
return 0
else:
self.logger.debug("Drop packet")
return 1
def test_Packet_in_4_icmpEcho2(self):
print "*** Case4: HOST2からHOST1以外の宛先IPへのIPパケットを受信 ***"
sr = SimpleForward()
sr.HOST_MACADDR1 = HOST_MACADDR1
sr.HOST_MACADDR2 = HOST_MACADDR2
dstMac = ROUTER_MACADDR2
srcMac = HOST_MACADDR2
srcIp = HOST_IPADDR2
dstIp = "91.189.89.22"
ttl = 64
datapath = _Datapath()
e = ethernet(dstMac, srcMac, ether.ETH_TYPE_IP)
iph = ipv4(4, 5, 0, 0, 0, 2, 0, ttl, 1, 0, srcIp, dstIp)
p = Packet()
p.add_protocol(e)
p.add_protocol(iph)
p.serialize()
packetIn = OFPPacketIn(datapath, match=OFPMatch(in_port=2), data=buffer(p.data))
ev = ofp_event.EventOFPPacketIn(packetIn)
result = sr.packet_in_handler(ev)
self.assertEqual(result, 1)
print ""
def _build_arp(self, vlan_enabled):
if vlan_enabled is True:
ethertype = ether.ETH_TYPE_8021Q
v = vlan(1, 1, 3, ether.ETH_TYPE_ARP)
else:
ethertype = ether.ETH_TYPE_ARP
e = ethernet(self.dst_mac, self.src_mac, ethertype)
p = Packet()
p.add_protocol(e)
if vlan_enabled is True:
p.add_protocol(v)
p.add_protocol(self.a)
p.serialize()
return p
def _build_lacp(self):
ethertype = ether.ETH_TYPE_SLOW
dst = SLOW_PROTOCOL_MULTICAST
e = ethernet(dst, self.actor_system, ethertype)
p = Packet()
p.add_protocol(e)
p.add_protocol(self.l)
p.serialize()
return p
def myPacketIn_handler(self,event):
msg = event.msg
datapath = msg.datapath
print("datapathId is %d"%datapath.id)
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
data = msg.data
in_port = msg.in_port
self.mac_to_port.setdefault(datapath.id,{})
pkt = Packet(data)
eth = pkt.get_protocol(ethernet)
src =eth.src
dst = eth.dst
self.mac_to_port[datapath.id][src] = in_port
if dst not in self.mac_to_port[datapath.id]:
out_port = ofproto.OFPP_FLOOD
else:
out_port = self.mac_to_port[datapath.id][dst]
actions = [parser.OFPActionOutput(out_port)]
out_msg = parser.OFPPacketOut(datapath,msg.buffer_id,in_port,actions,data)
datapath.send_msg(out_msg)
def arp_received_handler(self, ev):
msg = ev.ev.msg
datapath = msg.datapath
in_port = msg.match['in_port']
packet = Packet(msg.data)
arppkt = packet.get_protocol(arp.arp)
if arppkt.opcode == arp.ARP_REQUEST:
self.broadcast_to_end_nodes(msg)
try:
src_port, dst_port = db.handle_arp_packet(arppkt, datapath.id, in_port)
self.process_end_hw_addr_flows(src_port)
self.process_end_hw_addr_flows(dst_port)
if src_port[0] != dst_port[0]:
self.process_route(src_port, dst_port)
self.process_route(dst_port, src_port)
if arppkt.opcode == arp.ARP_REPLY:
target_switch = self.switches[dst_port[0]].switch
self.arp_packet_out(target_switch.dp, dst_port[1], msg.data)
except db.ArpTableNotFoundException:
pass
def packetIn_handler(self,event):
msg = event.msg
data = msg.data
datapath = msg.datapath
dapid = datapath.id
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.in_port
pkt = Packet(data)
eth = pkt.get_protocol(ethernet)
src = eth.src
dst = eth.dst
self.mac_to_port.setdefault(datapath.id,{})
self.mac_to_port[datapath.id].setdefault(src,in_port)
if dst in self.mac_to_port[dapid]:
out_port = self.mac_to_port[dapid][dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
pktout_msg = parser.OFPPacketOut(datapath=datapath,buffer_id=msg.buffer_id,in_port=in_port,actions=actions,data=data)
datapath.send_msg(pktout_msg)
def _packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
pkt = Packet(msg.data)
eth = pkt.get_protocols(ethernet)[0]
dst = eth.dst
src = eth.src
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)
# learn a mac address to avoid FLOOD next time.
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 = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
# install a flow to avoid packet_in next time
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
self.add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
in_port=in_port, actions=actions, data=data)
datapath.send_msg(out)
def packet_In_handler(self, event):
msg = event.msg
datapath = msg.datapath
if datapath.id not in self.allDatapath:
self.allDatapath[datapath.id] = datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
match = msg.match
data = msg.data
in_port = match["in_port"]
pkt = Packet(data)
eth = pkt.get_protocol(ethernet)
src = eth.src
dst = eth.dst
self.mac_to_port.setdefault(datapath.id, {})
self.mac_to_port[datapath.id][src] = in_port
if dst in self.mac_to_port[datapath.id]:
out_port = self.mac_to_port[datapath.id][dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
match = parser.OFPMatch(in_port=in_port, eth_src=src, eth_dst=dst)
instructions = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions=actions)]
self.addFlow(datapath=datapath, priority=1, match=match, instructions=instructions)
out_msg = parser.OFPPacketOut(
datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions, data=None
)
datapath.send_msg(out_msg)
