def _packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
dpid = datapath.id
in_port = msg.match['in_port']
self.mac_to_port.setdefault(dpid, {})
self.ip_to_port.setdefault(dpid, {})
flow_exists = 0
pkt = packet.Packet(msg.data)
#Ignore LLDP as it is used by the topology discovery module
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether.ETH_TYPE_LLDP:
return
header_list = dict((p.protocol_name, p)
for p in pkt.protocols if type(p) != str)
if ARP in header_list:
src_ip = header_list[ARP].src_ip
self.ip_to_port[dpid][src_ip] = in_port
dst = eth.dst
src = eth.src
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)]
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)
elif IPV4 in header_list:
drop_flag = False
dst = eth.dst
src = eth.src
proto = "any"
sport = "any"
dport = "any"
src_ip = header_list[IPV4].src
dst_ip = header_list[IPV4].dst
self.ip_to_port[dpid][src_ip] = in_port
if TCP in header_list:
proto="tcp"
sport = header_list[TCP].src_port
dport = header_list[TCP].dst_port
if UDP in header_list:
proto="udp"
sport = header_list[UDP].src_port
dport = header_list[UDP].dst_port
if ICMP in header_list:
proto="icmp"
if dst_ip in self.ip_to_port[dpid]:
out_port = self.ip_to_port[dpid][dst_ip]
else:
out_port = ofproto.OFPP_FLOOD
# Check if this packet hits any light probe rule and take
# necessary action
#print ("%d : %d : %s : %s : %s : %s : %s" % (in_port, out_port,
# proto, src_ip, sport, dst_ip, dport))
result = self.datapaths[datapath.id].fsm.inspect_packets(datapath,
in_port, out_port,
proto=proto, src_ip=src_ip, src_port=sport, dst_ip=dst_ip,
dst_port=dport, pkt_data=pkt)
sport = "any"
dport = "any"
if (result != None):
if "drop" in result:
drop_flag = True
actions = ""
else:
actions = [parser.OFPActionOutput(out_port)]
if drop_flag == False:
actions = [parser.OFPActionOutput(out_port)]
if (out_port != ofproto.OFPP_FLOOD):
reinstate_flag = False
if self.datapaths[datapath.id].flows.getflow(datapath,
src_ip, dst_ip, proto, sport, dport) == None:
self.datapaths[datapath.id].send_ip_flow(
ofproto.OFPFC_ADD, in_port, out_port,
proto=proto, src_ip=src_ip, src_port=sport,
dst_ip=dst_ip, dst_port=dport, drop=drop_flag)
if result != None:
matches_rule = True
if "reinstate" in result:
reinstate_flag = True
else:
matches_rule = False
self.datapaths[datapath.id].flows.addflow(datapath,
proto, src_ip, "any", dst_ip,
"any", out_port=out_port,
matches_rule=matches_rule,
reinstate=reinstate_flag)
else:
flow_exists = 1
#Now deal with the incoming packet if there is no flow
if flow_exists == 0:
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 _request_stats(self, datapath):
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
req = parser.OFPFlowStatsRequest(datapath)
datapath.send_msg(req)
