def install_rule(self, path, rule): act = [parser.OFPActionOutput(proto.OFPP_NORMAL, 0)] match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP, ip_proto=1, ipv4_src=rule[0], ipv4_dst=rule[1]) self.logger.debug("installing rule: %s", match) self.send_flow(path, 100, match, act)
def match(match_fields): """Return OpenFlow matches from dict. Args: match_fields (dict): match fields and values. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPMatch: matches. """ return parser.OFPMatch(**match_fields)
def unknown_flow(self, ev): switch = ev.msg.datapath data = ev.msg.data parsed_data = packet.Packet(data) in_port = ev.msg.match['in_port'] first_eth = parsed_data.get_protocols(eth.ethernet)[0] #Calling function to update arp and mac tables self.learn(switch, in_port, parsed_data) # Send where? if first_eth.dst in self.mac_tables[switch.id]: out_port = self.mac_tables[switch.id][first_eth.dst] else: out_port = of13.OFPP_FLOOD # Flow definition match = parser13.OFPMatch(in_port=in_port, eth_dst=first_eth.dst) actions = [parser13.OFPActionOutput(out_port)] instr = [ parser13.OFPInstructionActions(of13.OFPIT_APPLY_ACTIONS, actions) ] # Do we use BID? if ev.msg.buffer_id == of13.OFP_NO_BUFFER: # We got no buffer_id # ..so we send actual data self.send_packet_out(switch, out_port=out_port, data=data, actions=actions, in_port=in_port) if out_port != of13.OFPP_FLOOD: # ...and install a rule if it isn't a FLOOD self.send_new_flow(switch, match=match, instr=instr) else: # We have buffer id if out_port != of13.OFPP_FLOOD: # ...and are not FLOODing # so we install a rule and send packet out in one line self.send_new_flow(switch, match=match, instr=instr, buffer_id=ev.msg.buffer_id) else: # or just send a packet out, without a rule self.send_packet_out(switch, out_port=out_port, buffer_id=ev.msg.buffer_id, actions=actions, in_port=in_port) #Printing flow stats for every packet in. print "New flow stats reply with SW.ID : current flows stats: \n", self.flows, "\n" #Printing name and path of complete flow stat file for every packet in new_file_t = self.flow_stat_file[-1] print "For complete flow stats replies please open Sam-" + str( new_file_t) + ".csv" + " in " + os.getcwd() + "/ \n\n\n"
def tcp_udp_flows(self, vlan_id, nfvip, eth_type, nat_flows): return ( # Learn from coprocessor port/do inbound translation. (self.FROM_COPRO_TABLE, parser.OFPMatch(eth_type=eth_type, vlan_vid=vlan_id), nat_flows(nfvip)), # Packets from coprocessor go to tuple inbound table. (self.INTF_TABLE, parser.OFPMatch( eth_type=eth_type, ip_proto=socket.IPPROTO_TCP, in_port=self.COPROPORT, vlan_vid=vlan_id), [parser.OFPInstructionGotoTable(self.FROM_COPRO_TABLE)]), (self.INTF_TABLE, parser.OFPMatch( eth_type=eth_type, ip_proto=socket.IPPROTO_UDP, in_port=self.COPROPORT, vlan_vid=vlan_id), [parser.OFPInstructionGotoTable(self.FROM_COPRO_TABLE)]), # Packets from fake interface go outbound table. (self.INTF_TABLE, parser.OFPMatch( eth_type=eth_type, ip_proto=socket.IPPROTO_TCP, in_port=self.FAKEPORT, vlan_vid=vlan_id), [parser.OFPInstructionGotoTable(self.TO_COPRO_TABLE)]), (self.INTF_TABLE, parser.OFPMatch( eth_type=eth_type, ip_proto=socket.IPPROTO_UDP, in_port=self.FAKEPORT, vlan_vid=vlan_id), [parser.OFPInstructionGotoTable(self.TO_COPRO_TABLE)]))
def switch_features_handler(self, ev): datapath = ev.msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser # install the table-miss flow entry. match = parser.OFPMatch() actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)] self.add_flow(datapath, 0, match, actions)
def ipv6_flows(self, vlan_id, nfvip): return ( (self.INTF_TABLE, parser.OFPMatch(eth_type=ether.ETH_TYPE_IPV6, vlan_vid=vlan_id, ip_proto=socket.IPPROTO_ICMPV6, icmpv6_type=icmpv6.ND_NEIGHBOR_SOLICIT), self.apply_actions([parser.OFPActionOutput( ofp.OFPP_CONTROLLER)])), ) + self.tcp_udp_flows( vlan_id, nfvip, ether.ETH_TYPE_IPV6, self.natv6_flows)
def switch_features_handler(self, ev): dp = ev.msg.datapath ## init (per-data path) variables self.MAC_TO_PORT[dp.id] = {} self.pkt_count[dp.id] = 0 ## Note: check example for syntax how-to. #self.example() ## some debug output print("") print("") print("/// Switch connected. ID: {}".format(dp.id)) ## default "all to controller" flow match = parser.OFPMatch() action = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)] self.program_flow(dp, match, action, priority=0, idle_timeout=0, hard_timeout=0) ## Directly connect port 1 and 2 with proactive flow rules match = parser.OFPMatch(in_port=1) action = [parser.OFPActionOutput(2)] self.program_flow(dp, match, action, priority=100, idle_timeout=0, hard_timeout=0) match = parser.OFPMatch(in_port=2) action = [parser.OFPActionOutput(1)] self.program_flow(dp, match, action, priority=100, idle_timeout=0, hard_timeout=0)
def switch_features_handler(self, event): """ switch sent his features, check if Beba supported """ msg = event.msg datapath = msg.datapath LOG.info("Configuring switch %d..." % datapath.id) """ Set table 0 as stateful """ req = bebaparser.OFPExpMsgConfigureStatefulTable( datapath=datapath, table_id=0, stateful=1) datapath.send_msg(req) """ Set lookup extractor = {eth_dst} """ req = bebaparser.OFPExpMsgKeyExtract(datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofproto.OXM_OF_ETH_SRC], table_id=0) datapath.send_msg(req) """ Set update extractor = {eth_dst} """ req = bebaparser.OFPExpMsgKeyExtract(datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofproto.OXM_OF_ETH_SRC], table_id=0) datapath.send_msg(req) ########################################################################################### """ Set HF[1]=PKT_LEN [byte]""" req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=0, extractor_id=1, field=bebaproto.OXM_EXP_PKT_LEN ) datapath.send_msg(req) """ Update function: var( [count] , [value_to_be_varianced] , [avg_value] , [var_value]) = (IO1 , IN1 , IO2, IO3) has 4 inputs and 3 outputs OUT1 = FDV[0] = count OUT2 = FDV[1] = avg(IN1)*1000 OUT3 = FDV[2] = var(IN1) """ match = ofparser.OFPMatch() actions = [ofparser.OFPActionOutput(ofproto.OFPP_FLOOD), bebaparser.OFPExpActionSetDataVariable(table_id=0, opcode=bebaproto.OPCODE_VAR, output_fd_id=0, operand_1_hf_id=1, operand_2_fd_id=1, operand_3_fd_id=2)] self.add_flow(datapath=datapath, table_id=0, priority=0, match=match, actions=actions) """ $ sudo watch --color -n1 dpctl tcp:127.0.0.1:6634 stats-state -c
def test_reply_ttl_invalid_message_with_rate_limit(self): pkt = packet.Packet() pkt.add_protocol(ethernet.ethernet(dst='aa:bb:cc:dd:ee:ff')) pkt.add_protocol(ipv4.ipv4(proto=in_proto.IPPROTO_UDP)) pkt.add_protocol(udp.udp()) pkt.serialize() lswitch = l2.LogicalSwitch( id='lswitch1', topic='topic1', unique_key=9, version=1, ) self.app.db_store.update(lswitch) lrouter = l3.LogicalRouter( id='lrouter1', topic='topic1', version=1, unique_key=22, ports=[ l3.LogicalRouterPort( id='lrouter1-port1', unique_key=55, topic='topic1', mac='aa:bb:cc:dd:ee:ff', network='10.0.0.1/24', lswitch='lswitch1', ), ], ) self.app.db_store.update(lrouter) event = ofp_event.EventOFPMsgBase( msg=ofproto_parser.OFPPacketIn( datapath=mock.Mock(), reason=self.app.ofproto.OFPR_INVALID_TTL, match=ofproto_parser.OFPMatch( metadata=lswitch.unique_key, reg5=lrouter.unique_key, ), data=pkt.data, ) ) with mock.patch("dragonflow.controller.common." "icmp_error_generator.generate") as icmp_error: for _ in range(self.app.conf.router_ttl_invalid_max_rate * 2): self.app.packet_in_handler(event) self.assertEqual(self.app.conf.router_ttl_invalid_max_rate, icmp_error.call_count) icmp_error.assert_called_with(icmp.ICMP_TIME_EXCEEDED, icmp.ICMP_TTL_EXPIRED_CODE, mock.ANY, "10.0.0.1", mock.ANY)
def _switch_features_handler(self, ev): datapath = ev.msg.datapath self.datapaths[datapath.id] = datapath self.statistics.append({}) # All packets with a destination address in the IP address range 22.0.0.0/8 are expected to arrive at host H2 match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP, ipv4_src=('11.0.0.0', '255.0.0.0'), ipv4_dst=('22.0.0.0', '255.0.0.0')) actions = [parser.OFPActionOutput(2)] self.program_flow(datapath, match, actions, priority=20, hard_timeout=0, idle_timeout=0) # All packets with a destination address in the IP address range 33.0.0.0/8 are expected to arrive at host H3 match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP, ipv4_src=('11.0.0.0', '255.0.0.0'), ipv4_dst=('33.0.0.0', '255.0.0.0')) actions = [parser.OFPActionOutput(3)] self.program_flow(datapath, match, actions, priority=20, hard_timeout=0, idle_timeout=0) # traffic destined to 44.0.0.0/8 should be forwarded in such a way that the overall traffic is evenly distributed among the two hosts H2 and H3 # set group table self.send_group_mod(datapath) match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP, ipv4_src=('11.0.0.0', '255.0.0.0'), ipv4_dst=('44.0.0.0', '255.0.0.0')) actions = [parser.OFPActionGroup(group_id=1)] self.program_flow(datapath, match, actions, priority=10, hard_timeout=0, idle_timeout=0)
def _create_match(self, rule): """Create an OFPMatch instance based on the contents of an ACL_ENTRY. :param rule: The rule entry to create an OFPMatch instance from. :return: The OFPMatch instance. """ match = ofp13_parser.OFPMatch() ip_version = self._return_ip_version(rule.ip_src, rule.ip_dst) # Match IP layer (layer 3) if ip_version == 4: # Match IPv4 match.append_field(ofproto_v1_3.OXM_OF_ETH_TYPE, ethernet.ether.ETH_TYPE_IP) if rule.ip_src != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_IPV4_SRC, int(IPAddress(rule.ip_src))) if rule.ip_dst != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_IPV4_DST, int(IPAddress(rule.ip_dst))) else: # Match IPv6 match.append_field(ofproto_v1_3.OXM_OF_ETH_TYPE, ethernet.ether.ETH_TYPE_IPV6) if rule.ip_src != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_IPV6_SRC, IPAddress(rule.ip_src).words) if rule.ip_dst != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_IPV6_DST, IPAddress(rule.ip_dst).words) # Match transport layer (layer 4) if rule.tp_proto != self._RULE_WILDCARD: if rule.tp_proto == self._RULE_TCP: # Match TCP match.append_field(ofproto_v1_3.OXM_OF_IP_PROTO, ipv4.inet.IPPROTO_TCP) # covers IPv6 if rule.port_src != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_TCP_SRC, int(rule.port_src)) if rule.port_dst != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_TCP_DST, int(rule.port_dst)) elif rule.tp_proto == self._RULE_UDP: # Match UDP match.append_field(ofproto_v1_3.OXM_OF_IP_PROTO, ipv4.inet.IPPROTO_UDP) # covers IPv6 if rule.port_src != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_UDP_SRC, int(rule.port_src)) if rule.port_dst != self._RULE_WILDCARD: match.append_field(ofproto_v1_3.OXM_OF_UDP_DST, int(rule.port_dst)) return match
def send_midpoint_flows_for_path(self, in_path): """ Gets list of link and then based on them it sends flows only to the switches in the midpoints. That is the switch in the middle of path not at the endpoints Note that it only takes care of nodes in the middle very well. :type in_path: list :param in_path: list of link objects which collectively is called a path. """ u_dpids = self.find_unique_dpid_inlinklist(in_path) for temp_dpid in u_dpids: ports = self.find_ports_for_dpid(temp_dpid, in_path) if len(ports) == 2: match = ofproto_v1_3_parser.OFPMatch(in_port=ports[0]) actions = [ofproto_v1_3_parser.OFPActionOutput(port=ports[1])] self.add_flow(self.get_dp_switch_with_id(temp_dpid), 1, match, actions) match = ofproto_v1_3_parser.OFPMatch(in_port=ports[1]) actions = [ofproto_v1_3_parser.OFPActionOutput(port=ports[0])] self.add_flow(self.get_dp_switch_with_id(temp_dpid), 1, match, actions) elif len(ports) > 2: print("Need to be implemented.")
def launch_countermeasures(self, datapath, src_ip): """ Deploy a block rule based on IP source addresses """ match = parser.OFPMatch(eth_type=ether_types.ETH_TYPE_IP, ipv4_src=src_ip) # An empty action list indicates a drop rule self.set_flow(datapath, match, [], priority=2) warn = " WARNING! Traffic limit exceeded for IP {:s}!".format(src_ip) warn += " Dropping packets!" print(warn)
def load_arp_icmp(self): """ Enable ARP and ICMP protocol """ match = ofparser.OFPMatch(eth_type=0x0806) actions = [ofparser.OFPActionOutput(ofp.OFPP_FLOOD)] self.add_flow(datapath=self.datapath, table_id=0, priority=100, match=match, actions=actions) # ICMP packets flooding - simple, TEMPORARY and dull solution. match = ofparser.OFPMatch(eth_type=0x0800, ip_proto=1) actions = [ofparser.OFPActionOutput(ofp.OFPP_FLOOD)] self.add_flow(datapath=self.datapath, table_id=0, priority=1, match=match, actions=actions)
def test29(self, datapath): self.send_table_mod(datapath) self.send_key_lookup(datapath) self.send_key_update(datapath) act_type = osproto.OFPAT_EXP_SET_GLOBAL_STATE data = struct.pack('!I4x', act_type) a = ofparser.OFPActionExperimenterUnknown(experimenter=0XBEBABEBA, data=data) actions = [a] match = ofparser.OFPMatch(in_port=5, eth_type=0x800, ip_proto=1) self.add_flow(datapath, 100, match, actions)
def install_rule(self, **kwargs): ofproto = self.datapath.ofproto match = parser.OFPMatch(**kwargs.get('match')) action = parser.OFPActionOutput(kwargs.get('action').get('output')) self.wrapper.set_flow(self.datapath, match, [action], priority=priority)
def send_flows_for_path(self, in_link_path): """ Gets list of back up link and then based on them it sends flows to the switch. Note that it takes care of nodes in the middle very well. But for the endpoints, it assumes that the host is connected to port 1. :param in_link_path: List of link objects (a path) """ u_dpids = self.find_unique_dpid_inlinklist(in_link_path) visited_dpids = [] for temp_dpid in u_dpids: ports = self.find_ports_for_dpid(temp_dpid, in_link_path) if len(ports) == 2: visited_dpids.append(temp_dpid) match = ofproto_v1_3_parser.OFPMatch(in_port=ports[0]) actions = [ofproto_v1_3_parser.OFPActionOutput(port=ports[1])] self.add_flow(self.get_dp_switch_with_id(temp_dpid), 1, match, actions) match = ofproto_v1_3_parser.OFPMatch(in_port=ports[1]) actions = [ofproto_v1_3_parser.OFPActionOutput(port=ports[0])] self.add_flow(self.get_dp_switch_with_id(temp_dpid), 1, match, actions) elif len(ports) > 2: visited_dpids.append(temp_dpid) print("Need to be implemented.") end_points = [x for x in u_dpids if x not in visited_dpids] if len(end_points) > 2: print( "There is something wrong. There is two endpoints for a link") for temp_dpid_endpoint in end_points: other_port = self.find_ports_for_dpid(temp_dpid_endpoint, in_link_path) match = ofproto_v1_3_parser.OFPMatch(in_port=1) actions = [ofproto_v1_3_parser.OFPActionOutput(port=other_port[0])] self.add_flow(self.get_dp_switch_with_id(temp_dpid_endpoint), 1, match, actions) match = ofproto_v1_3_parser.OFPMatch() actions = [ofproto_v1_3_parser.OFPActionOutput(port=1)] self.add_flow(self.get_dp_switch_with_id(temp_dpid_endpoint), 1, match, actions)
def _flow_stats_requester(self): while True: for dp in self.switchports.keys(): switch = self.switches[dp] #Getting datapath from dpid cookie = cookie_mask = 0 match = parser13.OFPMatch() msg = parser13.OFPFlowStatsRequest(switch, 0, of13.OFPTT_ALL, of13.OFPP_ANY, of13.OFPG_ANY, cookie, cookie_mask, match) switch.send_msg(msg) hub.sleep(3) # Sleeping for three seconds
def _switch_features_handler(self, ev): # to make sure host H2 and H3 receive an equal share of the overall traffic # N2_address_range = IPNetwork("22.0.0.0/9") # N3_address_range = IPNetwork("22.128.0.0/9") datapath = ev.msg.datapath match = parser.OFPMatch( # from N1 to N2 eth_type = ether_types.ETH_TYPE_IP, ipv4_src = ('11.0.0.0', '255.0.0.0'), ipv4_dst = ('22.0.0.0', '255.128.0.0') ) actions = [parser.OFPActionOutput(2)] self.program_flow(datapath, match, actions, priority = 10, hard_timeout = 0, idle_timeout = 0) match = parser.OFPMatch( # from N1 to N3 eth_type = ether_types.ETH_TYPE_IP, ipv4_src = ('11.0.0.0', '255.0.0.0'), ipv4_dst = ('22.128.0.0', '255.128.0.0') ) actions = [parser.OFPActionOutput(3)] self.program_flow(datapath, match, actions, priority = 10, hard_timeout = 0, idle_timeout = 0)
def install_stateless(self, datapath): ################################ TAB 0: FWD ################################### match = ofparser.OFPMatch(eth_type=0x800, in_port=HOST_PORT) self.add_flow(datapath=datapath, priority=0, table_id=0, match=match, actions=[]) match = ofparser.OFPMatch(eth_type=0x800, ip_dscp=0) actions = [ofparser.OFPActionOutput(1 if datapath.id != 8 else 2)] self.add_flow(datapath=datapath, priority=100, table_id=0, match=match, actions=actions) # If: sw[i] is connected to the host -> deliver the packet match = ofparser.OFPMatch(eth_type=0x800, ipv4_dst=server_dict[datapath.id]) actions = [ofparser.OFPActionOutput(HOST_PORT)] self.add_flow(datapath=datapath, priority=10, table_id=0, match=match, actions=actions) # Else: forward it to the other ports for p in CORE_PORTS: # If ip_dst does not belong to the host directly connected to me, # drop the packet because it is already been forwarded match = ofparser.OFPMatch(in_port=p, eth_type=0x800) actions = [ofparser.OFPActionOutput(1 if p == 2 else 2)] self.add_flow(datapath=datapath, priority=0, table_id=0, match=match, actions=actions)
def _switch_features_handler(self, ev): dp = ev.msg.datapath # r: src, dst, sid, in_port, out_port rules = [r for r in ROUTING_TABLE if r[2] == dp.id] for r in rules: match = parser.OFPMatch( eth_type = ether_types.ETH_TYPE_IP, ipv4_src = r[0], ipv4_dst = r[1] ) actions = [parser.OFPActionOutput(r[4])] self.program_flow(dp, match, actions, priority=10, hard_timeout=0, idle_timeout=0)
def match_from_dict(match_dict): kwargs = {} for of_match, field in match_dict.items(): of_match = OLD_MATCH_FIELDS.get(of_match, of_match) test_config_condition(of_match not in MATCH_FIELDS, 'Unknown match field: %s' % of_match) try: encoded_field = MATCH_FIELDS[of_match](field) except TypeError: raise InvalidConfigError('%s cannot be type %s' % (of_match, type(field))) kwargs[of_match] = encoded_field return parser.OFPMatch(**kwargs)
def packet_in(self, event): msg = event.msg path = msg.datapath inpt = msg.match['in_port'] pckt = packet.Packet(msg.data) eth = pckt.get_protocols(ethernet.ethernet)[0] arpp = pckt.get_protocols(arp.arp)[0] acts = [parser.OFPActionOutput(inpt)] mtch = parser.OFPMatch(in_port=inpt, ipv4_dst=arpp.src_ip, ip_proto=0, eth_type=ether_types.ETH_TYPE_IP) self.send_flow(path, 1, mtch, acts) dest = eth.dst sorc = eth.src dpid = path.id self.mac_tab.setdefault(dpid, {}) self.mac_tab[dpid][sorc] = inpt outp = self.get_port(dest, dpid) acts = [parser.OFPActionOutput(outp)] if outp != proto.OFPP_FLOOD: mtch = parser.OFPMatch(in_port=outp, eth_dst=dest) self.send_flow(path, 1, mtch, acts) data = None if msg.buffer_id == proto.OFP_NO_BUFFER: data = msg.data out = parser.OFPPacketOut(datapath=path, buffer_id=msg.buffer_id, in_port=inpt, actions=acts, data=data) path.send_msg(out)
def remove_auth_flows(self, src_ip): """ removes the flows that capture knock sequence (identified with src_ip and priority) """ match_ipv4 = ofproto_v1_3_parser.OFPMatch() match_ipv4.append_field(ofproto_v1_3.OXM_OF_ETH_TYPE, ether_types.ETH_TYPE_IP) match_ipv4.append_field(ofproto_v1_3.OXM_OF_IPV4_SRC, int(IPAddress(src_ip))) match_ipv4.append_field(ofproto_v1_3.OXM_OF_IPV4_DST, int(IPAddress(self.server_ipv4_address))) for id in self.datapaths: delete_flow(self.datapaths[id], 3, match_ipv4)
def clear_table(self, datapath, table_id): """ Cleans all table values Parameters: - datapath = datapath to use - table_id = id of the table """ empty_match = ofparser.OFPMatch() instructions = [] flow_mod = self.remove_table_flows(datapath, table_id, empty_match, instructions) datapath.send_msg(flow_mod)
def install_edges(self, datapath): # Static routes configuration if datapath.id == 5: match = ofparser.OFPMatch(in_port=HOST_PORT) actions = [ofparser.OFPActionOutput(2)] self.add_flow(datapath=datapath, priority=0, table_id=0, match=match, actions=actions) match = ofparser.OFPMatch(in_port=HOST_PORT, eth_type=0x800, ipv4_dst=addrs[0]) actions = [ofparser.OFPActionOutput(1)] self.add_flow(datapath=datapath, priority=10, table_id=0, match=match, actions=actions) else: match = ofparser.OFPMatch(in_port=HOST_PORT) actions = [ofparser.OFPActionOutput(1)] self.add_flow(datapath=datapath, priority=0, table_id=0, match=match, actions=actions) if datapath.id == 1 or datapath.id == 3: match = ofparser.OFPMatch(in_port=HOST_PORT, eth_type=0x800, ipv4_dst=addrs[1]) actions = [ofparser.OFPActionOutput(2)] self.add_flow(datapath=datapath, priority=10, table_id=0, match=match, actions=actions) elif datapath.id == 7: match = ofparser.OFPMatch(in_port=HOST_PORT, eth_type=0x800, ipv4_dst=addrs[0]) actions = [ofparser.OFPActionOutput(2)] self.add_flow(datapath=datapath, priority=10, table_id=0, match=match, actions=actions) # Dumbly forward ALL for p in CORE_PORTS: match = ofparser.OFPMatch(in_port=p) actions = [ofparser.OFPActionOutput(1 if p == 2 else 2)] self.add_flow(datapath=datapath, priority=5, table_id=0, match=match, actions=actions)
def switch_features_handler(self, event): """ Switche sent his features, check if Beba supported """ msg = event.msg datapath = msg.datapath devices.append(datapath) LOG.info("Configuring switch %d..." % datapath.id) """ Set table 0 as stateful """ req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=0, stateful=1) datapath.send_msg(req) """ Set lookup extractor = {eth_dst} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofp.OXM_OF_ETH_DST], table_id=0) datapath.send_msg(req) """ Set update extractor = {eth_src} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofp.OXM_OF_ETH_SRC], table_id=0) datapath.send_msg(req) # for each input port, for each state for i in range(1, N + 1): for s in range(N + 1): match = ofparser.OFPMatch(in_port=i, state=s) if s == 0: out_port = ofp.OFPP_FLOOD else: out_port = s actions = [ bebaparser.OFPExpActionSetState(state=i, table_id=0, hard_timeout=10), ofparser.OFPActionOutput(out_port) #,ofparser.OFPActionOutput(ofp.OFPP_CONTROLLER, #ofp.OFPCML_NO_BUFFER) ] # Triggers flow mod self.add_flow(datapath=datapath, table_id=0, priority=0, match=match, actions=actions)
def add_tcp_table(self, datapath): ofproto = datapath.ofproto parser = datapath.ofproto_parser inst = [parser.OFPInstructionGotoTable(1)] match = parser.OFPMatch() mod = parser.OFPFlowMod(datapath=datapath, table_id=0, priority=0, match=match, idle_timeout=0, hard_timeout=0, instructions=inst) datapath.send_msg(mod) self.Flowcounter[datapath.id] += 1
def test13(self, datapath): self.send_table_mod(datapath) (global_state, global_state_mask ) = osparser.masked_global_state_from_str("*1*1*1*1*0*0*1*1*1*1*1*1*") actions = [ofparser.OFPActionOutput(6, 0)] match = ofparser.OFPMatch( in_port=5, eth_type=0x800, ip_proto=1, global_state=osparser.masked_global_state_from_str( "*1*1*1*1*0*0*1*1*1*1*1*1*")) self.add_flow(datapath, 200, match, actions) actions = [ osparser.OFPExpActionSetGlobalState( global_state=global_state, global_state_mask=global_state_mask) ] match = ofparser.OFPMatch(in_port=5, eth_type=0x800, ip_proto=1) self.add_flow(datapath, 100, match, actions) actions = [ofparser.OFPActionOutput(5, 0)] match = ofparser.OFPMatch(in_port=6, eth_type=0x800, ip_proto=1) self.add_flow(datapath, 200, match, actions)
def install_forward(self, datapath): match = ofparser.OFPMatch() actions = [ofparser.OFPActionOutput(ofproto.OFPP_FLOOD)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=10, match=match, instructions=inst) datapath.send_msg(mod)