#set page(header: [
    #set par(spacing: 6pt)
    #align(center)[#text(size: 11pt)[《网络工程》实验报告]]
    #v(-0.3em)
    #line(length: 100%, stroke: (thickness: 1pt))
],)

  #show heading: it => box(width: 100%)[
    #v(0.50em)
    #set text(font: hei)
    #it.body
  ]

#outline(title: "目录",depth: 3, indent: 1em)
#pagebreak()
#outline(
  title: [图目录],
  target: figure.where(kind: image),
)

  #show heading: it => box(width: 100%)[
    #v(0.50em)
    #set text(font: hei)
    #counter(heading).display()
    // #h(0.5em)
    #it.body
  ]
#set enum(indent: 0.5em,body-indent: 0.5em,)
#pagebreak()

= 实验概述
== 实验内容
#para[
  本次实验中有三个小实验：
  + 基于Openbox-S4测试SDN交换功能
  + 基于SDN 交换机源码处理openflow协议消息
  + 实验三 使用 REST API 接口查询交换机的相关功能数据
  本实验报告重点分析第二个小实验的实现细节。
]
== 实验要求
#para[
  1. 熟悉Openbox-S4的基本功能
  2. 熟悉OpenFlow协议的基本消息格式
  3. 熟悉OpenFlow协议的基本消息处理流程
  4. 熟悉REST API接口的基本使用
]
// Display inline code in a small box
// that retains the correct baseline.
#show raw.where(block: false): it => box(
  text(font: ("Consolas","FangSong_GB2312"), it),
  fill: luma(240),
  inset: (x: 3pt, y: 0pt),
  outset: (y: 3pt),
  radius: 2pt,
)

// Display block code in a larger block
// with more padding.
#show raw.where(block: true): it => block(
  text(font: ("Consolas","FangSong_GB2312"), it),
  fill: luma(240),
  inset: 10pt,
  radius: 4pt,
  width: 100%,
)

= 编写SDN交换机源码处理OpenFlow协议消息
#para[
  本次实验在`main_user_openflow.c`文件中实现了OpenFlow协议处理逻辑。代码通过多个函数处理不同类型的OpenFlow消息，包括Hello消息、Features Request消息、Flow Stats Request消息等。每个函数都根据消息类型生成相应的回复消息，并通过`send_openflow_message`函数发送给控制器。以下将逐一分析每个函数的实现细节。
]
== 本次实验所编写的协议

#para[
  本次实验实现了OpenFlow协议中的大部分消息处理功能。实验代码涵盖了从交换机特性查询到流表统计、端口统计等多种消息类型的处理。以下是实验编写协议的总结。
]
=== 实现的协议
#para[
  - OFPT_FEATURES_REQUEST：用于获取交换机支持的流表数量、缓冲区大小等特性信息。对应的处理函数为`handle_opfmsg_features_request`。
  - OFPT_GET_CONFIG_REQUEST：用于查询交换机的配置信息，如Miss Send Length等。对应的处理函数为`handle_ofpmsg_get_config_request`。
  - OFPT_MULTIPART_REQUEST：用于处理多种统计信息请求，包括交换机描述信息、流表信息、端口统计信息等。对应的处理函数包括：
    - `handle_ofpmsg_desc`
    - `handle_ofpmsg_flow_stats`
    - `handle_ofpmsg_aggregate`
    - `handle_ofpmsg_table`
    - `handle_ofpmsg_port_stats`
    - `handle_ofpmsg_group_features`
    - `handle_ofpmsg_port_desc`
  - OFPT_PACKET_OUT：用于处理控制器发送的数据包，并根据动作指示将数据包从指定端口发送出去。对应的处理函数为`handle_ofpmsg_packet_out`。
  - OFPT_ROLE_REQUEST：用于配置交换机的角色（如主控制器、从控制器等）。对应的处理函数为`handle__opfmsg_role_request`。
]
=== 组内分工
#para[
  本次实验由组内成员共同完成，每个成员负责不同的消息处理函数。以下是每个成员负责的函数列表。
  #align(center)[#table(
  columns: (55pt, auto),
  rows: 15pt,
  inset: 3pt,
  align: horizon+center,
  table.header(
    [分工], [函数]
  ),
  table.cell(rowspan: 7)[王李烜],
   "handle_opfmsg_features_request",
   "handle_ofpmsg_desc",
   "handle_ofpmsg_flow_stats",
   "handle_ofpmsg_aggregate",
   "handle_ofpmsg_table",
   "handle_ofpmsg_port_desc",
   "handle_opfmsg_role_request",
  table.cell(rowspan: 2)[廖中煜],
  "handle_ofpmsg_get_config_request",
  "handle_ofpmsg_packet_out",
  table.cell(rowspan: 2)[王誉潞],
  "handle_ofpmsg_port_stats",
  "handle_ofpmsg_group_features",
)]
]
== 相关数据结构

#para[
  在`main_user_openflow.c`中，定义了一些关键的数据结构和全局变量，用于处理OpenFlow协议的消息。主要的数据结构包括`ofp_header`、`ofp_switch_features`、`ofp_flow_stats`和`ofp_port_stats`等。这些数据结构用于处理OpenFlow协议中的不同消息类型，如交换机特性请求、流表统计请求、端口统计请求等。
]

#para[
  `ofp_header`结构体用于表示OpenFlow消息头，包含协议版本、消息类型、消息长度和事务ID等字段。`ofp_switch_features`结构体用于表示交换机的特性信息，如数据路径ID、缓冲区数量、流表数量等。`ofp_flow_stats`结构体用于表示流表统计信息，如流表项长度、优先级、数据包计数等。`ofp_port_stats`结构体用于表示端口统计信息，如端口号、接收数据包数、发送数据包数等。
]

== 消息头构建

#para[
  在OpenFlow协议中，每个消息都有一个消息头，用于标识消息的版本、类型、长度和事务ID。代码中实现了`build_opfmsg_header`函数，用于构建OpenFlow消息头。该函数接收消息长度、消息类型和事务ID作为参数，并填充消息头的各个字段。通过调用该函数，可以确保消息能够被正确解析和处理。
]

== 消息处理函数

#para[
  代码中实现了多个OpenFlow消息处理函数，每个函数对应一种OpenFlow消息类型。以下是每个函数的详细分析。
]

=== 处理Hello消息

#para[
  `handle_opfmsg_hello`函数用于处理控制器发送的Hello消息。Hello消息是OpenFlow协议中的基础消息，用于交换控制器和交换机之间的协议版本信息。函数首先检查消息头中的`version`字段，判断协议版本是否为1.3。如果版本匹配，则打印接收到的Hello消息；否则，生成一个错误消息并发送给控制器。函数返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_opfmsg_hello(struct ofp_buffer *ofpbuf) {
      if (ofpbuf->header.version == 0x04) {
          printf("RECV HELLO!\n\n\n");
      } else {
          struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_ERROR, ofpbuf->header.xid, sizeof(struct ofp_header));
          send_openflow_message(ofpbuf_reply, sizeof(struct ofp_header));
      }
      return HANDLE;
  }
  ```
]

=== 处理Features Request消息

#para[
  `handle_opfmsg_features_request`函数用于处理控制器发送的Features Request消息。该消息用于查询交换机的特性信息，如支持的流表数量、缓冲区大小等。函数生成一个Features Reply消息，并填充交换机的特性信息，如数据路径ID、缓冲区数量、流表数量等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_opfmsg_features_request(struct ofp_buffer *ofpbuf) {
      int feature_reply_len = sizeof(struct ofp_switch_features) + sizeof(struct ofp_header);
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_opfmsg_reply_ofpbuf(OFPT_FEATURES_REPLY, ofpbuf->header.xid, feature_reply_len);
      struct ofp_switch_features *feature_reply_msg = (struct ofp_switch_features *)ofpbuf_reply->data;

      feature_reply_msg->datapath_id = 0x0100000000000000;
      feature_reply_msg->n_buffers = htonl(46);
      feature_reply_msg->n_tables = 3;
      feature_reply_msg->capabilities = 0x7;

      send_openflow_message(ofpbuf_reply, feature_reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Get Config Request消息

#para[
  `handle_ofpmsg_get_config_request`函数用于处理控制器发送的Get Config Request消息。该消息用于查询交换机的配置信息，如Miss Send Length等。函数生成一个Get Config Reply消息，并填充交换机的配置信息。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_get_config_request(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_switch_config) + sizeof(struct ofp_header);
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_GET_CONFIG_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_switch_config *switch_config_reply = (struct ofp_switch_config *)ofpbuf_reply->data;

      switch_config_reply->flags = htons(0x0000);
      switch_config_reply->miss_send_len = htons(32);

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Description Request消息

#para[
  `handle_ofpmsg_desc`函数用于处理控制器发送的Description Request消息。该消息用于查询交换机的描述信息，如制造商、硬件版本等。函数生成一个Multipart Reply消息，并填充交换机的描述信息。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_desc(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart) + sizeof(struct ofp_desc_stats);
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *ofpmp_reply = (struct ofp_multipart *)ofpbuf_reply->data;

      static const char *default_mfr_desc = "Wanglixuan";
      static const char *default_hw_desc = "Lixuan_OpenBox";
      static const char *default_sw_desc = "Lixuan_Driver";
      static const char *default_serial_desc = "Lixuan OpenBox Series";
      static const char *default_dp_desc = "None";

      ofpmp_reply->type = htons(OFPMP_DESC);
      ofpmp_reply->flags = htonl(OFPMP_REPLY_MORE_NO);
      snprintf(ofpmp_reply->ofpmp_desc[0].mfr_desc, sizeof ofpmp_reply->ofpmp_desc[0].mfr_desc, "%s", default_mfr_desc);
      snprintf(ofpmp_reply->ofpmp_desc[0].hw_desc, sizeof ofpmp_reply->ofpmp_desc[0].hw_desc, "%s", default_hw_desc);
      snprintf(ofpmp_reply->ofpmp_desc[0].sw_desc, sizeof ofpmp_reply->ofpmp_desc[0].sw_desc, "%s", default_sw_desc);
      snprintf(ofpmp_reply->ofpmp_desc[0].serial_num, sizeof ofpmp_reply->ofpmp_desc[0].serial_num, "%s", default_serial_desc);
      snprintf(ofpmp_reply->ofpmp_desc[0].dp_desc, sizeof ofpmp_reply->ofpmp_desc[0].dp_desc, "%s", default_dp_desc);

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Flow Stats Request消息

#para[
  `handle_ofpmsg_flow_stats`函数用于处理控制器发送的Flow Stats Request消息。该消息用于查询交换机的流表统计信息。函数生成一个Multipart Reply消息，并设置消息类型为Flow Stats。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_flow_stats(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart);
      struct ofp_buffer *reply_buffer = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *multipart_reply = (struct ofp_multipart *)reply_buffer->data;

      multipart_reply->type = htons(OFPMP_FLOW);
      multipart_reply->flags = htonl(OFPMP_REPLY_MORE_NO);

      send_openflow_message(reply_buffer, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Aggregate Stats Request消息

#para[
  `handle_ofpmsg_aggregate`函数用于处理控制器发送的Aggregate Stats Request消息。该消息用于查询交换机的聚合统计信息。函数生成一个Multipart Reply消息，并填充聚合统计信息，如数据包计数、字节计数等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_aggregate(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart) + sizeof(struct ofp_aggregate_stats_reply);
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *ofpmp_reply = (struct ofp_multipart *)ofpbuf_reply->data;

      ofpmp_reply->type = htons(OFPMP_AGGREGATE);
      ofpmp_reply->flags = htonl(OFPMP_REPLY_MORE_NO);

      ofpmp_reply->ofpmp_aggregate_reply[0].packet_count = htonll(46);
      ofpmp_reply->ofpmp_aggregate_reply[0].byte_count = htonll(2025);
      ofpmp_reply->ofpmp_aggregate_reply[0].flow_count = htonll(200);

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Table Stats Request消息

#para[
  `handle_ofpmsg_table`函数用于处理控制器发送的Table Stats Request消息。该消息用于查询交换机的流表统计信息。函数生成一个Multipart Reply消息，并填充流表统计信息，如匹配计数、查找计数等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_table(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart) + sizeof(struct ofp_table_stats) * 1;
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *ofpmp_reply = (struct ofp_multipart *)ofpbuf_reply->data;

      ofpmp_reply->type = htons(OFPMP_TABLE);
      ofpmp_reply->flags = htonl(OFPMP_REPLY_MORE_NO);

      ofpmp_reply->table_stats[0].matched_count = htonll(2025);
      ofpmp_reply->table_stats[0].table_id = 0;
      ofpmp_reply->table_stats[0].lookup_count = htonll(46);
      ofpmp_reply->table_stats[0].active_count = htonl(1);

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Port Stats Request消息

#para[
  `handle_ofpmsg_port_stats`函数用于处理控制器发送的Port Stats Request消息。该消息用于查询交换机的端口统计信息。函数生成一个Multipart Reply消息，并填充端口统计信息，如持续时间、接收数据包数等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_port_stats(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart) + sizeof(struct ofp_port_stats) * nmps.cnt;
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *ofpmp_reply = (struct ofp_multipart *)ofpbuf_reply->data;

      ofpmp_reply->type = htons(OFPMP_PORT_STATS);
      ofpmp_reply->flags = htonl(OFPMP_REPLY_MORE_NO);

      for (int i = 0; i < nmps.cnt; i++) {
          ofpmp_reply->ofpmp_port_stats[i] = nmps.ports[i].stats;
          ofpmp_reply->ofpmp_port_stats[i].duration_sec = htonl(2025);
          ofpmp_reply->ofpmp_port_stats[i].duration_nsec = htonl(51);
      }

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Group Features Request消息

#para[
  `handle_ofpmsg_group_features`函数用于处理控制器发送的Group Features Request消息。该消息用于查询交换机的组表特性信息。函数生成一个Multipart Reply消息，并填充组表特性信息，如最大组数等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_group_features(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_group_features) + 8;
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_group_features *group = (struct ofp_group_features *)ofpbuf_reply->data;

      group->types = htons(OFPMP_GROUP_FEATURES);
      group->max_groups[0] = htonl(0xdeadbeef);

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Port Description Request消息

#para[
  `handle_ofpmsg_port_desc`函数用于处理控制器发送的Port Description Request消息。该消息用于查询交换机的端口描述信息。函数生成一个Multipart Reply消息，并填充端口描述信息，如端口状态等。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_port_desc(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_multipart) + sizeof(struct ofp_port) * nmps.cnt;
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_MULTIPART_REPLY, ofpbuf->header.xid, reply_len);
      struct ofp_multipart *ofpmp_reply = (struct ofp_multipart *)ofpbuf_reply->data;

      ofpmp_reply->type = htons(OFPMP_PORT_DESC);
      ofpmp_reply->flags = htonl(OFPMP_REPLY_MORE_NO);

      for (int i = 0; i < nmps.cnt; i++) {
          ofpmp_reply->ofpmp_port_desc[i] = nmps.ports[i].state;
      }

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]

=== 处理Packet Out消息

#para[
  `handle_ofpmsg_packet_out`函数用于处理控制器发送的Packet Out消息。该消息用于指示交换机将数据包从指定端口发送出去。函数解析消息中的动作列表，判断动作类型是否为`OFPAT_OUTPUT`，并根据动作指示的端口号调用`nms_exec_action`函数将数据包发送出去。函数返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_ofpmsg_packet_out(struct ofp_buffer *ofpbuf) {
      struct ofp_packet_out *out = (struct ofp_packet_out *)ofpbuf;
      struct ofp_action_output *action = (struct ofp_action_output *)&out->actions[0];
      int action_len = ntohs(out->actions_len);
      struct eth_header *eth = (struct eth_header *)&ofpbuf->data[sizeof(struct ofp_packet_out) - sizeof(struct ofp_header) + action_len];
      int send_len = ntohs(ofpbuf->header.length) - sizeof(struct ofp_packet_out) - action_len;

      if (action_len == 0) {
          nms_exec_action(ntohl(out->in_port), OFPP_FLOOD, eth, send_len, -1);
      } else {
          while (action_len > 0) {
              if (action->type == OFPAT_OUTPUT) {
                  nms_exec_action(ntohl(out->in_port), ntohl(action->port), eth, send_len, -1);
              }
              action_len -= sizeof(struct ofp_action_output);
              action++;
          }
      }
      return HANDLE;
  }
  ```
]

=== 处理Role Request消息

#para[
  `handle_opfmsg_role_request`函数用于处理控制器发送的Role Request消息。该消息用于配置交换机的角色（如主控制器、从控制器等）。函数生成一个Role Reply消息，并填充角色配置信息。通过`send_openflow_message`函数将回复消息发送给控制器，并返回`HANDLE`表示消息已处理。

  ```c
  static enum ofperr handle_opfmsg_role_request(struct ofp_buffer *ofpbuf) {
      int reply_len = sizeof(struct ofp_header) + sizeof(struct ofp_role);
      struct ofp_buffer *ofpbuf_reply = (struct ofp_buffer *)build_reply_ofpbuf(OFPT_ROLE_REPLY, ofpbuf->header.xid, reply_len);
      memcpy(ofpbuf_reply->data, ofpbuf->data, sizeof(struct ofp_role));
      ofpbuf_reply->header.type = OFPT_ROLE_REPLY;

      send_openflow_message(ofpbuf_reply, reply_len);
      return HANDLE;
  }
  ```
]
== 实验结果
#para[
  在控制器与交换机之间进行抓包，分析报文的交互过程。控制器发送不同类型的OpenFlow消息给交换机，交换机接收并处理消息，并返回相应的回复消息。通过抓包分析，可以看到消息的交互过程，包括消息头、消息类型、消息长度等字段的解析和处理。用这种方式来验证协议编写的正确性。
  
  实现的子协议种类较多，这里只展示部分报文内容。
]
=== OFPT_ROLE_REPLY
#para[
  + OFPT_ROLE_REPLY类型消息。此消息用于配置交换机的角色（如主控制器、从控制器等）。下面的@slave_request 是控制器发送的Role Request消息。
    #figure(image("slave.png",fit:"stretch",format:"png"),caption:"OFPT_ROLE_REQUEST消息",)<slave_request>
    如图@slave_reply 所示，交换机接收并处理后返回的Role Reply消息。
    #figure(image("slave_reply.png",fit:"stretch",format:"png"),caption:"OFPT_ROLE_REPLY消息",)<slave_reply>
    这说明交换机已经接收到了控制器发送的Role Request消息，并返回了Role Reply消息。
]
=== OFPT_MULTIPART_REPLY
#para[
  + OFPMP_DESC类型消息。此消息用于查询交换机的描述信息，包括制造商、硬件版本、软件版本、序列号和数据路径描述等。
    #figure(image("lixuanwang.png",fit:"stretch",format:"png"),caption:"OFPMP_DESC消息",)
    可以看到图中的消息包含了制造商、硬件版本、软件版本、序列号和数据路径描述等信息（此处使用了自己的信息进行标记与区分）。
  + OFPMP_TABLE类型消息。此消息用于查询交换机的流表统计信息，包括匹配计数、查找计数等。
    #figure(image("table.png",fit:"stretch",format:"png"),caption:"OFPMP_TABLE消息",)
    可以看到图中的消息包含了匹配计数、查找计数等信息（此处修改为了自己设置的值）。
]
= 实验总结
#para[

]
#show heading: it => box(width: 100%)[
  #v(0.50em)
  #set text(font: hei)
  // #counter(heading).display()
  // #h(0.5em)
  #it.body
]
#pagebreak()
#bibliography("ref.yml",full: true,title: "参考文献",style:"gb-7714-2015-numeric")


/*
根据这个网站的格式示范https://github.com/typst/hayagriva/blob/main/docs/file-format.md   
为这些网页生成.yml文件
https://opennetworking.org/wp-content/uploads/2014/10/openflow-spec-v1.3.0.pdf
https://www.cnblogs.com/goldsunshine/p/7262484.html
https://www.jianshu.com/p/acfeae1771b3
https://www.jianshu.com/p/82e238eb8d14
*/