实验3：OpenFlow协议分析实践

一、实验目的

1. 能够运用 wireshark 对 OpenFlow 协议数据交互过程进行抓包；
2. 能够借助包解析工具，分析与解释 OpenFlow协议的数据包交互过程与机制。

二、实验环境

1. 下载虚拟机软件Oracle VisualBox；
2. 在虚拟机中安装Ubuntu 20.04 Desktop amd64，并完整安装Mininet；

三、实验要求

（一）基本要求

1. 搭建下图所示拓扑，完成相关 IP 配置，并实现主机与主机之间的 IP 通信。用抓包软件获取控制器与交换机之间的通信数据包。
   

   • 使用Miniedit构建拓扑结构：

     

   • 设置IP地址段和子网掩码：

     

   • 按要求修改主机地址等

     

   • 也可以在第一次实验拓扑结果的基础上直接修改：

     

2. 查看抓包结果，分析OpenFlow协议中交换机与控制器的消息交互过程，画出相关交互图或流程图。

   • 运行wireshark，选择any模式，运行1.中的拓扑结构，并输入pingall命令。

     

   • 查看抓包结果：

     1. OFPT_HELLO:

        从控制器6633端口到交换机43544端口，使用OpenFlow1.0协议：

        

        从交换机43544端口到控制器6633端口，使用OpenFlow1.5协议：

        

        OFPT_HELLO后双方协定使用OpenFlow1.0协议。

     2. OFPT_FEATURES_REQUEST

        从控制器6633端口到交换机43544端口，请求特征信息。

        

     3. OFPT_SET_CONFIG：

        从控制器6633接口到交换机43544端口

        

     4. OFPT_PORT_STATUS:

        从交换机43544端口到控制器6633端口当交换机端口发生变化时，告知控制器相应的端口状态。

        

     5. OFPT_FEATURES_REPLY:

        交换机43544端口到控制器6633端口，回复特征信息。

        

     6. OFPT_PACKET_IN:

        分析抓取的数据包。

        

     7. OFPT_FLOW_MOD:

        分析抓取的flow_mod数据包，控制器通过6633端口向交换机43546端口下发流表项，指导数据的转发处理。

        

     8. OFPT_PACKET_OUT：

        控制器6633端口向交换机43546端口发送数据，并告知交换机输出到65531端口。

        

   9. 流程图：
      

3. 回答问题：交换机与控制器建立通信时是使用TCP协议还是UDP协议？

   使用TCP协议，可以在抓取的数据包中体现

   

   也可以直接查看拓扑代码

   

（二）进阶要求

1. 将抓包结果对照OpenFlow源码，了解OpenFlow主要消息类型对应的数据结构定义。

   • 所有信号类型：

     enum ofp_type {
         /* Immutable messages. */
         OFPT_HELLO,               /* Symmetric message */
         OFPT_ERROR,               /* Symmetric message */
         OFPT_ECHO_REQUEST,        /* Symmetric message */
         OFPT_ECHO_REPLY,          /* Symmetric message */
         OFPT_VENDOR,              /* Symmetric message */
     
         /* Switch configuration messages. */
         OFPT_FEATURES_REQUEST,    /* Controller/switch message */
         OFPT_FEATURES_REPLY,      /* Controller/switch message */
         OFPT_GET_CONFIG_REQUEST,  /* Controller/switch message */
         OFPT_GET_CONFIG_REPLY,    /* Controller/switch message */
         OFPT_SET_CONFIG,          /* Controller/switch message */
     
         /* Asynchronous messages. */
         OFPT_PACKET_IN,           /* Async message */
         OFPT_FLOW_REMOVED,        /* Async message */
         OFPT_PORT_STATUS,         /* Async message */
     
         /* Controller command messages. */
         OFPT_PACKET_OUT,          /* Controller/switch message */
         OFPT_FLOW_MOD,            /* Controller/switch message */
         OFPT_PORT_MOD,            /* Controller/switch message */
     
         /* Statistics messages. */
         OFPT_STATS_REQUEST,       /* Controller/switch message */
         OFPT_STATS_REPLY,         /* Controller/switch message */
     
         /* Barrier messages. */
         OFPT_BARRIER_REQUEST,     /* Controller/switch message */
         OFPT_BARRIER_REPLY,       /* Controller/switch message */
     
         /* Queue Configuration messages. */
         OFPT_QUEUE_GET_CONFIG_REQUEST,  /* Controller/switch message */
         OFPT_QUEUE_GET_CONFIG_REPLY     /* Controller/switch message */
     
     };
     

   • OPFT_HELLO

     /* Header on all OpenFlow packets. */
     struct ofp_header {
         uint8_t version;    /* OFP_VERSION. */
         uint8_t type;       /* One of the OFPT_ constants. */
         uint16_t length;    /* Length including this ofp_header. */
         uint32_t xid;       /* Transaction id associated with this packet.
                                Replies use the same id as was in the request
                                to facilitate pairing. */
     };
     /* OFPT_HELLO.  This message has an empty body, but implementations must
      * ignore any data included in the body, to allow for future extensions. */
     struct ofp_hello {
         struct ofp_header header;
     };
     

     

   • OFPT_FEATURES_REQUEST

     结构与HELLO相似

     

   • OFPT_SET_CONFIG

     /* Switch configuration. */
     struct ofp_switch_config {
         struct ofp_header header;
         uint16_t flags;             /* OFPC_* flags. */
         uint16_t miss_send_len;     /* Max bytes of new flow that datapath should
                                        send to the controller. */
     };
     

     

   • OFPT_PORT_STATUS

     /* A physical port has changed in the datapath */
     struct ofp_port_status {
         struct ofp_header header;
         uint8_t reason;          /* One of OFPPR_*. */
         uint8_t pad[7];          /* Align to 64-bits. */
         struct ofp_phy_port desc;
     };
     

     

   • OFPT_FEATURES_REPLY

     /* Description of a physical port */
     struct ofp_phy_port {
         uint16_t port_no;
         uint8_t hw_addr[OFP_ETH_ALEN];
         char name[OFP_MAX_PORT_NAME_LEN]; /* Null-terminated */
     
         uint32_t config;        /* Bitmap of OFPPC_* flags. */
         uint32_t state;         /* Bitmap of OFPPS_* flags. */
     
         /* Bitmaps of OFPPF_* that describe features.  All bits zeroed if
          * unsupported or unavailable. */
         uint32_t curr;          /* Current features. */
         uint32_t advertised;    /* Features being advertised by the port. */
         uint32_t supported;     /* Features supported by the port. */
         uint32_t peer;          /* Features advertised by peer. */
     };
     
     /* Switch features. */
     struct ofp_switch_features {
         struct ofp_header header;
         uint64_t datapath_id;   /* Datapath unique ID.  The lower 48-bits are for
                                    a MAC address, while the upper 16-bits are
                                    implementer-defined. */
     
         uint32_t n_buffers;     /* Max packets buffered at once. */
     
         uint8_t n_tables;       /* Number of tables supported by datapath. */
         uint8_t pad[3];         /* Align to 64-bits. */
     
         /* Features. */
         uint32_t capabilities;  /* Bitmap of support "ofp_capabilities". */
         uint32_t actions;       /* Bitmap of supported "ofp_action_type"s. */
     
         /* Port info.*/
         struct ofp_phy_port ports[0];  /* Port definitions.  The number of ports
                                           is inferred from the length field in
                                           the header. */
     };
     

     

   • OFPT_PACKET_IN

     struct ofp_packet_in {
         struct ofp_header header;
         uint32_t buffer_id;     /* ID assigned by datapath. */
         uint16_t total_len;     /* Full length of frame. */
         uint16_t in_port;       /* Port on which frame was received. */
         uint8_t reason;         /* Reason packet is being sent (one of OFPR_*) */
         uint8_t pad;
         uint8_t data[0];        /* Ethernet frame, halfway through 32-bit word,
                                    so the IP header is 32-bit aligned.  The
                                    amount of data is inferred from the length
                                    field in the header.  Because of padding,
                                    offsetof(struct ofp_packet_in, data) ==
                                    sizeof(struct ofp_packet_in) - 2. */
     };
     

     

   • OFPT_FLOW_MOD

     struct ofp_flow_mod {
         struct ofp_header header;
         struct ofp_match match;      /* Fields to match */
         uint64_t cookie;             /* Opaque controller-issued identifier. */
     
         /* Flow actions. */
         uint16_t command;             /* One of OFPFC_*. */
         uint16_t idle_timeout;        /* Idle time before discarding (seconds). */
         uint16_t hard_timeout;        /* Max time before discarding (seconds). */
         uint16_t priority;            /* Priority level of flow entry. */
         uint32_t buffer_id;           /* Buffered packet to apply to (or -1).
                                          Not meaningful for OFPFC_DELETE*. */
         uint16_t out_port;            /* For OFPFC_DELETE* commands, require
                                          matching entries to include this as an
                                          output port.  A value of OFPP_NONE
                                          indicates no restriction. */
         uint16_t flags;               /* One of OFPFF_*. */
         struct ofp_action_header actions[0]; /* The action length is inferred
                                                 from the length field in the
                                                 header. */
     };
     

     

   • OFPT_PACKET_OUT

     /* Send packet (controller -> datapath). */
     struct ofp_packet_out {
         struct ofp_header header;
         uint32_t buffer_id;           /* ID assigned by datapath (-1 if none). */
         uint16_t in_port;             /* Packet's input port (OFPP_NONE if none). */
         uint16_t actions_len;         /* Size of action array in bytes. */
         struct ofp_action_header actions[0]; /* Actions. */
         /* uint8_t data[0]; */        /* Packet data.  The length is inferred
                                          from the length field in the header.
                                          (Only meaningful if buffer_id == -1.) */
     };
     

     

四、心得

实验难度：

• 本次实验以验证性实验为主，主要是了解并掌握OpenFlow通讯过程中，数据包的流动过程和对应的信息数据结构，对比前几次实验较为简单。

实验过程遇到的困难及解决办法：

• 运行wireshark后，运行拓扑结构后，未在抓包列表中找到OFPT_FLOW_MOD类型，多次重复无果后，尝试输入pingall得到想要的结果

心得：

• 本次实验难度较低，更重要的是对于OpenFlow协议的数据包交互过程与机制的了解与学习，面对较多的信息内容，实验过程中需要有耐心，一步一步地去完成。
• 对于wireshark的使用更加熟练，也了解到了对应数据包内容的含义，对OpenFlow协议有了进一步的了解。