OPENFLOW WireShark 协议解析

前言

1.openflow是什么？

OpenFlow是一种网络通信协议，应用于SDN架构中控制器和转发器之间的通信。软件定义网络SDN的一个核心思想就是“转发、控制分离”，要实现转、控分离，就需要在控制器与转发器之间建立一个通信接口标准，允许控制器直接访问和控制转发器的转发平面。OpenFlow引入了“流表”的概念，转发器通过流表来指导数据包的转发。控制器正是通过OpenFlow提供的接口在转发器上部署相应的流表，从而实现对转发平面的控制。

2.WireShark是什么？

Wireshark是一款开源的网络协议分析工具，可以帮助用户捕获和分析网络数据包。通过Wireshark工具，我们可以深入了解数据包的传输过程，进而解决网络问题和优化网络性能。

一.实验目的

1.能够运用wireshark对OpenFlow协议数据交互过程进行抓包

2.能够借助包解析工具，分析和解释OpenFlow协议的数据进行包交互过程与机制

二.实验环境
实验环境通常包括 Ubuntu 操作系统、Mininet模拟器以及 Wireshark抓包工具。例如，可以在 Ubuntu 20.04 上安装 Mininet 和 Wireshark，然后通过 Mininet 搭建网络拓扑，并使用 Wireshark 捕获控制器与交换机之间的通信数据包。

实验过程：

搭建拓扑并配置网段

配置IP地址

保存为python文件

运行wireshark并选择any抓包

执行文件并使用pingall命令

抓包结果：

1.Hello

2. FEATURES_REQUEST

3.SET_CONFIG

4. PORT_STATUS

5. FEATURES_REPLY

6. PACKET_IN

7. PACKET_OUT

8. FLOW_MOD

流程图：

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

答 ：交换机与控制器建立通信时是使用TCP协议。

将抓包结果对照OpenFlow源码

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. */

};

struct ofp_hello {

    struct ofp_header header;

};

源码参数格式与HELLO相同，与上述ofp_header结构体中数据相同

/* 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. */

};

/* 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;

};

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. */

};

/* 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. */

};

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. */

};

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.) */

};

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. */

};

struct ofp_action_header {

    uint16_t type;                  /* One of OFPAT_*. */

    uint16_t len;                   /* Length of action, including this

                                       header.  This is the length of action,

                                       including any padding to make it

                                       64-bit aligned. */

    uint8_t pad[4];

};

实验总结：

1.通过这次实验，我对于OpenFlow协议的理解有了更深一步的理解。

2.纸上得来终觉浅，对于之前理论上的学习，通过这次实验也是感觉到了不足之处，好在通过老师和同学的帮助也是顺利的完成了整个实验

3.对SDN概念的实际应用有了新的体会

实验心得：

1.更加熟练的使用OpenFlow协议

2.对SDN有了更深层次的理解

3.对如何设计和优化网络架构有了新的认识

4.认识到了Openflow应用场景的广泛