mininet ryu manager 数据重定向实现

Question

为什么每个if都跑进去了但没有实现重定向呢

原本的server add是10.0.1.2

<import logging

from ryu.base import app_manager

from ryu.controller import ofp_event

from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER

from ryu.controller.handler import set_ev_cls

from ryu.ofproto import ofproto_v1_3

from ryu.lib.packet import packet, ethernet, ipv4, tcp, ether_types, in_proto, arp

logging.basicConfig(level=logging.INFO)



class SimpleSwitch13(app_manager.RyuApp):

    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]



    def __init__(self, *args, **kwargs):

        super(SimpleSwitch13, self).__init__(*args, **kwargs)

        self.mac_to_port = {}



    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)

    def switch_features_handler(self, ev):

        datapath = ev.msg.datapath

        ofproto = datapath.ofproto

        parser = datapath.ofproto_parser



        # Install 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 add_flow(self, datapath, priority, match, actions, buffer_id=None):

        ofproto = datapath.ofproto

        parser = datapath.ofproto_parser



        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,

                                             actions)]

        if buffer_id:

            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id, priority=priority, idle_timeout=5,  match=match, instructions=inst)

        else:

            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,

                                    match=match, instructions=inst)

        datapath.send_msg(mod)



    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)

    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.Packet(msg.data)

        eth = pkt.get_protocols(ethernet.ethernet)[0]



        if eth.ethertype == ether_types.ETH_TYPE_LLDP:

            # Ignore LLDP packet

            return



        dst = eth.dst

        src = eth.src



        dpid = datapath.id

        self.mac_to_port.setdefault(dpid, {})



        # 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:

            logging.info("Received")

            match = parser.OFPMatch(in_port=in_port, eth_dst=dst)



            # Check if it is a TCP packet

            if eth.ethertype == ether_types.ETH_TYPE_IP:

                logging.info("Received IPv4 packet")

                ip = pkt.get_protocol(ipv4.ipv4)

                if ip.proto == in_proto.IPPROTO_TCP:

                    logging.info("Received TCP packet")

                    tcp_pkt = pkt.get_protocol(tcp.tcp)



                    # Check if it is a TCP SYN segment

                    if tcp_pkt.bits & tcp.TCP_SYN !=0:

                        logging.info("Handling TCP SYN segment")

                        new_dst_ip = '10.0.1.3'

                        new_dst_mac = '00:00:00:00:00:02'

                        # Create and install a new flow entry

                        actions = [parser.OFPActionSetField(ipv4_dst=new_dst_ip),  parser.OFPActionSetField(eth_dst=new_dst_mac),  parser.OFPActionOutput(out_port)]

                        self.add_flow(datapath, 1, match, actions)



                        # Send out Packet_Out SDN packet with the TCP SYN segment

                        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,

                                                  in_port=in_port, actions=actions, data=msg.data)

                        datapath.send_msg(out)

                        

                        return

            # Otherwise, install a regular flow entry

            self.add_flow(datapath, 2, match, actions)



        data = None

        if msg.buffer_id == ofproto.OFP_NO_BUFFER:

            logging.info("111")

            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)>
mininet里面是一个sdn控制器和三个host通过s1连接，<client.setIP(ip='10.0.1.5/24', intf='client-eth0')

    server1.setIP(ip='10.0.1.2/24', intf='server1-eth0')

    server2.setIP(ip='10.0.1.3/24', intf='server2-eth0')



    client.setMAC(mac="00:00:00:00:00:03", intf='client-eth0')

    server1.setMAC(mac="00:00:00:00:00:01", intf='server1-eth0')

    server2.setMAC(mac="00:00:00:00:00:02", intf='server2-eth0')    

    >

    client.setIP(ip='10.0.1.5/24', intf='client-eth0')

    server1.setIP(ip='10.0.1.2/24', intf='server1-eth0')

    server2.setIP(ip='10.0.1.3/24', intf='server2-eth0')



    client.setMAC(mac="00:00:00:00:00:03", intf='client-eth0')

    server1.setMAC(mac="00:00:00:00:00:01", intf='server1-eth0')

    server2.setMAC(mac="00:00:00:00:00:02", intf='server2-eth0')    

    

Answer 1

引自强大而免费的微信小程序：皆我百晓生。

实现数据重定向的关键是在控制器实现对数据包的流量处理和流表项的添加。在给定的代码中，控制器先通过学习源MAC地址发送到的端口，然后根据目标MAC地址决定发送到哪个端口。

要实现重定向，需要在以下部分添加代码：

1. 在控制器的packet_in_handler方法中，根据目标MAC地址判断是否需要重定向。
2. 在需要重定向的情况下，修改目标IP地址和目标MAC地址，并将重定向动作添加到actions列表中。
3. 添加新的流表项，将符合条件的目标MAC地址和目标IP地址进行重定向。

根据您的要求，可以在以下部分添加重定向的代码：

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:
    logging.info("Received")
    match = parser.OFPMatch(in_port=in_port, eth_dst=dst)

    # Check if it is a TCP packet
    if eth.ethertype == ether_types.ETH_TYPE_IP:
        logging.info("Received IPv4 packet")
        ip = pkt.get_protocol(ipv4.ipv4)
        if ip.proto == in_proto.IPPROTO_TCP:
            logging.info("Received TCP packet")
            tcp_pkt = pkt.get_protocol(tcp.tcp)

            # Check if it is a TCP SYN segment
            if tcp_pkt.bits & tcp.TCP_SYN !=0:
                logging.info("Handling TCP SYN segment")
                new_dst_ip = '10.0.1.3'
                new_dst_mac = '00:00:00:00:00:02'
                # Create and install a new flow entry
                actions = [parser.OFPActionSetField(ipv4_dst=new_dst_ip), parser.OFPActionSetField(eth_dst=new_dst_mac), parser.OFPActionOutput(out_port)]
                self.add_flow(datapath, 1, match, actions)
                # Send out Packet_Out SDN packet with the TCP SYN segment
                out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                          in_port=in_port, actions=actions, data=msg.data)
                datapath.send_msg(out)
                return
    # Otherwise, install a regular flow entry
    self.add_flow(datapath, 2, match, actions)

这段代码首先判断目标MAC地址是否在控制器已学习的地址表中，如果在地址表中，则直接发送到对应端口；如果不在地址表中，则进行数据包洪泛。如果目标MAC地址在地址表中，进一步判断是否是TCP包，并且是否是TCP SYN段。如果是TCP SYN段，将目标IP地址和目标MAC地址修改为重定向的地址，并安装一个新的流表项进行重定向。然后将重定向动作添加到actions列表中，并发送出Packet_Out消息。

另外，在switch_features_handler方法中，已经设置了一个表项来处理TableMiss情况，这个表项会将所有未匹配的流量发送到控制器，可以根据需要对此进行修改。

注意，要使上述重定向生效，需要保证Mininet网络连接到正确的控制器，并且控制器代码能够正常运行。另外，需要确保主机的IP和MAC地址与控制器中设置的一致。

希望能对您的问题有所帮助！如果您还有任何疑问，请随时向我提问。