# OpenFlow v1.3 Messages and Structures

## Controller-to-Switch Messages

### Handshake

class `ryu.ofproto.ofproto_v1_3_parser.``OFPFeaturesRequest`(datapath)

  Features request message

  The controller sends a feature request to the switch upon session establishment.

  This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

  Example:

      def send_features_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPFeaturesRequest(datapath)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPFeaturesRequest": {}
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPSwitchFeatures`(datapath, datapath_id=None, n_buffers=None, n_tables=None, auxiliary_id=None, capabilities=None)

  Features reply message

  The switch responds with a features reply message to a features request.

  This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

  Example:

      @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
      def switch_features_handler(self, ev):
          msg = ev.msg

          self.logger.debug('OFPSwitchFeatures received: '
                            'datapath_id=0x%016x n_buffers=%d '
                            'n_tables=%d auxiliary_id=%d '
                            'capabilities=0x%08x',
                            msg.datapath_id, msg.n_buffers, msg.n_tables,
                            msg.auxiliary_id, msg.capabilities)

  JSON Example:

      {
         "OFPSwitchFeatures": {
            "auxiliary_id": 99,
            "capabilities": 79,
            "datapath_id": 9210263729383,
            "n_buffers": 0,
            "n_tables": 255
         }
      }

### Switch Configuration

class `ryu.ofproto.ofproto_v1_3_parser.``OFPSetConfig`(datapath, flags=0, miss_send_len=0)

  Set config request message

  The controller sends a set config request message to set configuraion parameters.

  Attribute | Description
  --- | ---
  flags | Bitmap of the following flags. OFPC_FRAG_NORMAL OFPC_FRAG_DROP OFPC_FRAG_REASM
  miss_send_len | Max bytes of new flow that datapath should send to the controller

  Example:

      def send_set_config(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPSetConfig(datapath, ofp.OFPC_FRAG_NORMAL, 256)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPSetConfig": {
            "flags": 0,
            "miss_send_len": 128
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGetConfigRequest`(datapath)

  Get config request message

  The controller sends a get config request to query configuration parameters in the switch.

  Example:

      def send_get_config_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPGetConfigRequest(datapath)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPGetConfigRequest": {}
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGetConfigReply`(datapath, flags=None, miss_send_len=None)

  Get config reply message

  The switch responds to a configuration request with a get config reply message.

  Attribute | Description
  --- | ---
  flags | Bitmap of the following flags. OFPC_FRAG_NORMAL OFPC_FRAG_DROP OFPC_FRAG_REASM OFPC_FRAG_MASK
  miss_send_len | Max bytes of new flow that datapath should send to the controller

  Example:

      @set_ev_cls(ofp_event.EventOFPGetConfigReply, MAIN_DISPATCHER)
      def get_config_reply_handler(self, ev):
          msg = ev.msg
          dp = msg.datapath
          ofp = dp.ofproto
          flags = []

          if msg.flags & ofp.OFPC_FRAG_NORMAL:
              flags.append('NORMAL')
          if msg.flags & ofp.OFPC_FRAG_DROP:
              flags.append('DROP')
          if msg.flags & ofp.OFPC_FRAG_REASM:
              flags.append('REASM')
          self.logger.debug('OFPGetConfigReply received: '
                            'flags=%s miss_send_len=%d',
                            ','.join(flags), msg.miss_send_len)

  JSON Example:

      {
         "OFPGetConfigReply": {
            "flags": 0,
            "miss_send_len": 128
         }
      }

### Flow Table Configuration

class `ryu.ofproto.ofproto_v1_3_parser.``OFPTableMod`(datapath, table_id, config)

  Flow table configuration message

  The controller sends this message to configure table state.

  Attribute | Description
  --- | ---
  table_id | ID of the table (OFPTT_ALL indicates all tables)
  config | Bitmap of the following flags. OFPTC_DEPRECATED_MASK (3)

  Example:

      def send_table_mod(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPTableMod(datapath, 1, 3)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPTableMod": {
            "config": 0,
            "table_id": 255
         }
      }

### Modify State Messages

class `ryu.ofproto.ofproto_v1_3_parser.``OFPFlowMod`(datapath, cookie=0, cookie_mask=0, table_id=0, command=0, idle_timeout=0, hard_timeout=0, priority=32768, buffer_id=4294967295, out_port=0, out_group=0, flags=0, match=None, instructions=None)

  Modify Flow entry message

  The controller sends this message to modify the flow table.

  Attribute | Description
  --- | ---
  cookie | Opaque controller-issued identifier
  cookie_mask | Mask used to restrict the cookie bits that must match when the command is `OPFFC_MODIFY*` or `OFPFC_DELETE*`
  table_id | ID of the table to put the flow in
  command | One of the following values. OFPFC_ADD OFPFC_MODIFY OFPFC_MODIFY_STRICT OFPFC_DELETE OFPFC_DELETE_STRICT
  idle_timeout | Idle time before discarding (seconds)
  hard_timeout | Max time before discarding (seconds)
  priority | Priority level of flow entry
  buffer_id | Buffered packet to apply to (or OFP_NO_BUFFER)
  out_port | For `OFPFC_DELETE*` commands, require matching entries to include this as an output port
  out_group | For `OFPFC_DELETE*` commands, require matching entries to include this as an output group
  flags | Bitmap of the following flags. OFPFF_SEND_FLOW_REM OFPFF_CHECK_OVERLAP OFPFF_RESET_COUNTS OFPFF_NO_PKT_COUNTS OFPFF_NO_BYT_COUNTS
  match | Instance of `OFPMatch`
  instructions | list of `OFPInstruction*` instance

  Example:

      def send_flow_mod(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          cookie = cookie_mask = 0
          table_id = 0
          idle_timeout = hard_timeout = 0
          priority = 32768
          buffer_id = ofp.OFP_NO_BUFFER
          match = ofp_parser.OFPMatch(in_port=1, eth_dst='ff:ff:ff:ff:ff:ff')
          actions = [ofp_parser.OFPActionOutput(ofp.OFPP_NORMAL, 0)]
          inst = [ofp_parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
                                                   actions)]
          req = ofp_parser.OFPFlowMod(datapath, cookie, cookie_mask,
                                      table_id, ofp.OFPFC_ADD,
                                      idle_timeout, hard_timeout,
                                      priority, buffer_id,
                                      ofp.OFPP_ANY, ofp.OFPG_ANY,
                                      ofp.OFPFF_SEND_FLOW_REM,
                                      match, inst)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPFlowMod": {
            "buffer_id": 65535,
            "command": 0,
            "cookie": 0,
            "cookie_mask": 0,
            "flags": 0,
            "hard_timeout": 0,
            "idle_timeout": 0,
            "instructions": [
               {
                  "OFPInstructionActions": {
                     "actions": [
                        {
                           "OFPActionSetField": {
                              "field": {
                                 "OXMTlv": {
                                    "field": "vlan_vid",
                                    "mask": null,
                                    "value": 258
                                 }
                              }
                           }
                        },
                        {
                           "OFPActionCopyTtlOut": {
                              "len": 8,
                              "type": 11
                           }
                        },
                        {
                           "OFPActionCopyTtlIn": {
                              "len": 8,
                              "type": 12
                           }
                        },
                        {
                           "OFPActionCopyTtlIn": {
                              "len": 8,
                              "type": 12
                           }
                        },
                        {
                           "OFPActionPopPbb": {
                              "len": 8,
                              "type": 27
                           }
                        },
                        {
                           "OFPActionPushPbb": {
                              "ethertype": 4660,
                              "len": 8,
                              "type": 26
                           }
                        },
                        {
                           "OFPActionPopMpls": {
                              "ethertype": 39030,
                              "len": 8,
                              "type": 20
                           }
                        },
                        {
                           "OFPActionPushMpls": {
                              "ethertype": 34887,
                              "len": 8,
                              "type": 19
                           }
                        },
                        {
                           "OFPActionPopVlan": {
                              "len": 8,
                              "type": 18
                           }
                        },
                        {
                           "OFPActionPushVlan": {
                              "ethertype": 33024,
                              "len": 8,
                              "type": 17
                           }
                        },
                        {
                           "OFPActionDecMplsTtl": {
                              "len": 8,
                              "type": 16
                           }
                        },
                        {
                           "OFPActionSetMplsTtl": {
                              "len": 8,
                              "mpls_ttl": 10,
                              "type": 15
                           }
                        },
                        {
                           "OFPActionDecNwTtl": {
                              "len": 8,
                              "type": 24
                           }
                        },
                        {
                           "OFPActionSetNwTtl": {
                              "len": 8,
                              "nw_ttl": 10,
                              "type": 23
                           }
                        },
                        {
                           "OFPActionSetQueue": {
                              "len": 8,
                              "queue_id": 3,
                              "type": 21
                           }
                        },
                        {
                           "OFPActionGroup": {
                              "group_id": 99,
                              "len": 8,
                              "type": 22
                           }
                        },
                        {
                           "OFPActionOutput": {
                              "len": 16,
                              "max_len": 65535,
                              "port": 6,
                              "type": 0
                           }
                        }
                     ],
                     "len": 160,
                     "type": 3
                  }
               },
               {
                  "OFPInstructionActions": {
                     "actions": [
                        {
                           "OFPActionSetField": {
                              "field": {
                                 "OXMTlv": {
                                    "field": "eth_src",
                                    "mask": null,
                                    "value": "01:02:03:04:05:06"
                                 }
                              }
                           }
                        },
                        {
                           "OFPActionSetField": {
                              "field": {
                                 "OXMTlv": {
                                    "field": "pbb_uca",
                                    "mask": null,
                                    "value": 1
                                 }
                              }
                           }
                        }
                     ],
                     "len": 40,
                     "type": 4
                  }
               }
            ],
            "match": {
               "OFPMatch": {
                  "length": 14,
                  "oxm_fields": [
                     {
                        "OXMTlv": {
                           "field": "eth_dst",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     }
                  ],
                  "type": 1
               }
            },
            "out_group": 4294967295,
            "out_port": 4294967295,
            "priority": 123,
            "table_id": 1
         }
      }

      {
         "OFPFlowMod": {
            "buffer_id": 65535,
            "command": 0,
            "cookie": 0,
            "cookie_mask": 0,
            "flags": 0,
            "hard_timeout": 0,
            "idle_timeout": 0,
            "instructions": [
               {
                  "OFPInstructionGotoTable": {
                     "len": 8,
                     "table_id": 1,
                     "type": 1
                  }
               }
            ],
            "match": {
               "OFPMatch": {
                  "length": 22,
                  "oxm_fields": [
                     {
                        "OXMTlv": {
                           "field": "in_port",
                           "mask": null,
                           "value": 6
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "eth_src",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     }
                  ],
                  "type": 1
               }
            },
            "out_group": 4294967295,
            "out_port": 4294967295,
            "priority": 123,
            "table_id": 0
         }
      }

      {
         "OFPFlowMod": {
            "buffer_id": 65535,
            "command": 0,
            "cookie": 0,
            "cookie_mask": 0,
            "flags": 0,
            "hard_timeout": 0,
            "idle_timeout": 0,
            "instructions": [
               {
                  "OFPInstructionMeter": {
                     "len": 8,
                     "meter_id": 1,
                     "type": 6
                  }
               },
               {
                  "OFPInstructionActions": {
                     "actions": [
                        {
                           "OFPActionOutput": {
                              "len": 16,
                              "max_len": 65535,
                              "port": 6,
                              "type": 0
                           }
                        }
                     ],
                     "len": 24,
                     "type": 3
                  }
               }
            ],
            "match": {
               "OFPMatch": {
                  "length": 14,
                  "oxm_fields": [
                     {
                        "OXMTlv": {
                           "field": "eth_dst",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     }
                  ],
                  "type": 1
               }
            },
            "out_group": 4294967295,
            "out_port": 4294967295,
            "priority": 123,
            "table_id": 1
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupMod`(datapath, command=0, type_=0, group_id=0, buckets=None)

  Modify group entry message

  The controller sends this message to modify the group table.

  Attribute | Description
  --- | ---
  command | One of the following values. OFPGC_ADD OFPGC_MODIFY OFPGC_DELETE
  type | One of the following values. OFPGT_ALL OFPGT_SELECT OFPGT_INDIRECT OFPGT_FF
  group_id | Group identifier
  buckets | list of `OFPBucket`

  `type` attribute corresponds to `type_` parameter of __init__.

  Example:

      def send_group_mod(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          port = 1
          max_len = 2000
          actions = [ofp_parser.OFPActionOutput(port, max_len)]

          weight = 100
          watch_port = 0
          watch_group = 0
          buckets = [ofp_parser.OFPBucket(weight, watch_port, watch_group,
                                          actions)]

          group_id = 1
          req = ofp_parser.OFPGroupMod(datapath, ofp.OFPGC_ADD,
                                       ofp.OFPGT_SELECT, group_id, buckets)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPGroupMod": {
            "buckets": [
               {
                  "OFPBucket": {
                     "actions": [
                        {
                           "OFPActionOutput": {
                              "len": 16,
                              "max_len": 65535,
                              "port": 2,
                              "type": 0
                           }
                        }
                     ],
                     "len": 32,
                     "watch_group": 1,
                     "watch_port": 1,
                     "weight": 1
                  }
               }
            ],
            "command": 0,
            "group_id": 1,
            "type": 0
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortMod`(datapath, port_no=0, hw_addr='00:00:00:00:00:00', config=0, mask=0, advertise=0)

  Port modification message

  The controller sneds this message to modify the behavior of the port.

  Attribute | Description
  --- | ---
  port_no | Port number to modify
  hw_addr | The hardware address that must be the same as hw_addr of `OFPPort` of `OFPSwitchFeatures`
  config | Bitmap of configuration flags. OFPPC_PORT_DOWN OFPPC_NO_RECV OFPPC_NO_FWD OFPPC_NO_PACKET_IN
  mask | Bitmap of configuration flags above to be changed
  advertise | Bitmap of the following flags. OFPPF_10MB_HD OFPPF_10MB_FD OFPPF_100MB_HD OFPPF_100MB_FD OFPPF_1GB_HD OFPPF_1GB_FD OFPPF_10GB_FD OFPPF_40GB_FD OFPPF_100GB_FD OFPPF_1TB_FD OFPPF_OTHER OFPPF_COPPER OFPPF_FIBER OFPPF_AUTONEG OFPPF_PAUSE OFPPF_PAUSE_ASYM

  Example:

      def send_port_mod(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          port_no = 3
          hw_addr = 'fa:c8:e8:76:1d:7e'
          config = 0
          mask = (ofp.OFPPC_PORT_DOWN | ofp.OFPPC_NO_RECV |
                  ofp.OFPPC_NO_FWD | ofp.OFPPC_NO_PACKET_IN)
          advertise = (ofp.OFPPF_10MB_HD | ofp.OFPPF_100MB_FD |
                       ofp.OFPPF_1GB_FD | ofp.OFPPF_COPPER |
                       ofp.OFPPF_AUTONEG | ofp.OFPPF_PAUSE |
                       ofp.OFPPF_PAUSE_ASYM)
          req = ofp_parser.OFPPortMod(datapath, port_no, hw_addr, config,
                                      mask, advertise)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPPortMod": {
            "advertise": 4096,
            "config": 0,
            "hw_addr": "00:11:00:00:11:11",
            "mask": 0,
            "port_no": 1
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterMod`(datapath, command=0, flags=1, meter_id=1, bands=None)

  Meter modification message

  The controller sends this message to modify the meter.

  Attribute | Description
  --- | ---
  command | One of the following values. OFPMC_ADD OFPMC_MODIFY OFPMC_DELETE
  flags | Bitmap of the following flags. OFPMF_KBPS OFPMF_PKTPS OFPMF_BURST OFPMF_STATS
  meter_id | Meter instance
  bands | list of the following class instance. OFPMeterBandDrop OFPMeterBandDscpRemark OFPMeterBandExperimenter

  JSON Example:

      {
         "OFPMeterMod": {
            "bands": [
               {
                  "OFPMeterBandDrop": {
                     "burst_size": 10,
                     "len": 16,
                     "rate": 1000,
                     "type": 1
                  }
               },
               {
                  "OFPMeterBandDscpRemark": {
                     "burst_size": 10,
                     "len": 16,
                     "prec_level": 1,
                     "rate": 1000,
                     "type": 2
                  }
               },
               {
                  "OFPMeterBandExperimenter": {
                     "burst_size": 10,
                     "experimenter": 999,
                     "len": 16,
                     "rate": 1000,
                     "type": 65535
                  }
               }
            ],
            "command": 0,
            "flags": 14,
            "meter_id": 100
         }
      }

### Multipart Messages

class `ryu.ofproto.ofproto_v1_3_parser.``OFPDescStatsRequest`(datapath, flags=0, type_=None)

  Description statistics request message

  The controller uses this message to query description of the switch.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_desc_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPDescStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPDescStatsRequest": {
            "flags": 0,
            "type": 0
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPDescStatsReply`(datapath, type_=None, **kwargs)

  Description statistics reply message

  The switch responds with this message to a description statistics request.

  Attribute | Description
  --- | ---
  body | Instance of `OFPDescStats`

  Example:

      @set_ev_cls(ofp_event.EventOFPDescStatsReply, MAIN_DISPATCHER)
      def desc_stats_reply_handler(self, ev):
          body = ev.msg.body

          self.logger.debug('DescStats: mfr_desc=%s hw_desc=%s sw_desc=%s '
                            'serial_num=%s dp_desc=%s',
                            body.mfr_desc, body.hw_desc, body.sw_desc,
                            body.serial_num, body.dp_desc)

  JSON Example:

      {
         "OFPDescStatsReply": {
            "body": {
               "OFPDescStats": {
                  "dp_desc": "dp",
                  "hw_desc": "hw",
                  "mfr_desc": "mfr",
                  "serial_num": "serial",
                  "sw_desc": "sw"
               }
            },
            "flags": 0,
            "type": 0
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPFlowStatsRequest`(datapath, flags=0, table_id=255, out_port=4294967295, out_group=4294967295, cookie=0, cookie_mask=0, match=None, type_=None)

  Individual flow statistics request message

  The controller uses this message to query individual flow statistics.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  table_id | ID of table to read
  out_port | Require matching entries to include this as an output port
  out_group | Require matching entries to include this as an output group
  cookie | Require matching entries to contain this cookie value
  cookie_mask | Mask used to restrict the cookie bits that must match
  match | Instance of `OFPMatch`

  Example:

      def send_flow_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          cookie = cookie_mask = 0
          match = ofp_parser.OFPMatch(in_port=1)
          req = ofp_parser.OFPFlowStatsRequest(datapath, 0,
                                               ofp.OFPTT_ALL,
                                               ofp.OFPP_ANY, ofp.OFPG_ANY,
                                               cookie, cookie_mask,
                                               match)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPFlowStatsRequest": {
            "cookie": 0,
            "cookie_mask": 0,
            "flags": 0,
            "match": {
               "OFPMatch": {
                  "length": 4,
                  "oxm_fields": [],
                  "type": 1
               }
            },
            "out_group": 4294967295,
            "out_port": 4294967295,
            "table_id": 0,
            "type": 1
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPFlowStatsReply`(datapath, type_=None, **kwargs)

  Individual flow statistics reply message

  The switch responds with this message to an individual flow statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPFlowStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
      def flow_stats_reply_handler(self, ev):
          flows = []
          for stat in ev.msg.body:
              flows.append('table_id=%s '
                           'duration_sec=%d duration_nsec=%d '
                           'priority=%d '
                           'idle_timeout=%d hard_timeout=%d flags=0x%04x '
                           'cookie=%d packet_count=%d byte_count=%d '
                           'match=%s instructions=%s' %
                           (stat.table_id,
                            stat.duration_sec, stat.duration_nsec,
                            stat.priority,
                            stat.idle_timeout, stat.hard_timeout, stat.flags,
                            stat.cookie, stat.packet_count, stat.byte_count,
                            stat.match, stat.instructions))
          self.logger.debug('FlowStats: %s', flows)

  JSON Example:

      {
         "OFPFlowStatsReply": {
            "body": [
               {
                  "OFPFlowStats": {
                     "byte_count": 0,
                     "cookie": 0,
                     "duration_nsec": 115277000,
                     "duration_sec": 358,
                     "flags": 0,
                     "hard_timeout": 0,
                     "idle_timeout": 0,
                     "instructions": [],
                     "length": 56,
                     "match": {
                        "OFPMatch": {
                           "length": 4,
                           "oxm_fields": [],
                           "type": 1
                        }
                     },
                     "packet_count": 0,
                     "priority": 65535,
                     "table_id": 0
                  }
               },
               {
                  "OFPFlowStats": {
                     "byte_count": 0,
                     "cookie": 0,
                     "duration_nsec": 115055000,
                     "duration_sec": 358,
                     "flags": 0,
                     "hard_timeout": 0,
                     "idle_timeout": 0,
                     "instructions": [
                        {
                           "OFPInstructionActions": {
                              "actions": [
                                 {
                                    "OFPActionOutput": {
                                       "len": 16,
                                       "max_len": 0,
                                       "port": 4294967290,
                                       "type": 0
                                    }
                                 }
                              ],
                              "len": 24,
                              "type": 4
                           }
                        }
                     ],
                     "length": 88,
                     "match": {
                        "OFPMatch": {
                           "length": 10,
                           "oxm_fields": [
                              {
                                 "OXMTlv": {
                                    "field": "eth_type",
                                    "mask": null,
                                    "value": 2054
                                 }
                              }
                           ],
                           "type": 1
                        }
                     },
                     "packet_count": 0,
                     "priority": 65534,
                     "table_id": 0
                  }
               },
               {
                  "OFPFlowStats": {
                     "byte_count": 238,
                     "cookie": 0,
                     "duration_nsec": 511582000,
                     "duration_sec": 316220,
                     "flags": 0,
                     "hard_timeout": 0,
                     "idle_timeout": 0,
                     "instructions": [
                        {
                           "OFPInstructionGotoTable": {
                              "len": 8,
                              "table_id": 1,
                              "type": 1
                           }
                        }
                     ],
                     "length": 80,
                     "match": {
                        "OFPMatch": {
                           "length": 22,
                           "oxm_fields": [
                              {
                                 "OXMTlv": {
                                    "field": "in_port",
                                    "mask": null,
                                    "value": 6
                                 }
                              },
                              {
                                 "OXMTlv": {
                                    "field": "eth_src",
                                    "mask": null,
                                    "value": "f2:0b:a4:7d:f8:ea"
                                 }
                              }
                           ],
                           "type": 1
                        }
                     },
                     "packet_count": 3,
                     "priority": 123,
                     "table_id": 0
                  }
               },
               {
                  "OFPFlowStats": {
                     "byte_count": 98,
                     "cookie": 0,
                     "duration_nsec": 980901000,
                     "duration_sec": 313499,
                     "flags": 0,
                     "hard_timeout": 0,
                     "idle_timeout": 0,
                     "instructions": [
                        {
                           "OFPInstructionActions": {
                              "actions": [
                                 {
                                    "OFPActionSetField": {
                                       "field": {
                                          "OXMTlv": {
                                             "field": "vlan_vid",
                                             "mask": null,
                                             "value": 258
                                          }
                                       }
                                    }
                                 },
                                 {
                                    "OFPActionCopyTtlOut": {
                                       "len": 8,
                                       "type": 11
                                    }
                                 },
                                 {
                                    "OFPActionCopyTtlIn": {
                                       "len": 8,
                                       "type": 12
                                    }
                                 },
                                 {
                                    "OFPActionCopyTtlIn": {
                                       "len": 8,
                                       "type": 12
                                    }
                                 },
                                 {
                                    "OFPActionPopPbb": {
                                       "len": 8,
                                       "type": 27
                                    }
                                 },
                                 {
                                    "OFPActionPushPbb": {
                                       "ethertype": 4660,
                                       "len": 8,
                                       "type": 26
                                    }
                                 },
                                 {
                                    "OFPActionPopMpls": {
                                       "ethertype": 39030,
                                       "len": 8,
                                       "type": 20
                                    }
                                 },
                                 {
                                    "OFPActionPushMpls": {
                                       "ethertype": 34887,
                                       "len": 8,
                                       "type": 19
                                    }
                                 },
                                 {
                                    "OFPActionPopVlan": {
                                       "len": 8,
                                       "type": 18
                                    }
                                 },
                                 {
                                    "OFPActionPushVlan": {
                                       "ethertype": 33024,
                                       "len": 8,
                                       "type": 17
                                    }
                                 },
                                 {
                                    "OFPActionDecMplsTtl": {
                                       "len": 8,
                                       "type": 16
                                    }
                                 },
                                 {
                                    "OFPActionSetMplsTtl": {
                                       "len": 8,
                                       "mpls_ttl": 10,
                                       "type": 15
                                    }
                                 },
                                 {
                                    "OFPActionDecNwTtl": {
                                       "len": 8,
                                       "type": 24
                                    }
                                 },
                                 {
                                    "OFPActionSetNwTtl": {
                                       "len": 8,
                                       "nw_ttl": 10,
                                       "type": 23
                                    }
                                 },
                                 {
                                    "OFPActionSetQueue": {
                                       "len": 8,
                                       "queue_id": 3,
                                       "type": 21
                                    }
                                 },
                                 {
                                    "OFPActionGroup": {
                                       "group_id": 99,
                                       "len": 8,
                                       "type": 22
                                    }
                                 },
                                 {
                                    "OFPActionOutput": {
                                       "len": 16,
                                       "max_len": 65535,
                                       "port": 6,
                                       "type": 0
                                    }
                                 }
                              ],
                              "len": 160,
                              "type": 3
                           }
                        },
                        {
                           "OFPInstructionActions": {
                              "actions": [
                                 {
                                    "OFPActionSetField": {
                                       "field": {
                                          "OXMTlv": {
                                             "field": "eth_src",
                                             "mask": null,
                                             "value": "01:02:03:04:05:06"
                                          }
                                       }
                                    }
                                 },
                                 {
                                    "OFPActionSetField": {
                                       "field": {
                                          "OXMTlv": {
                                             "field": "pbb_uca",
                                             "mask": null,
                                             "value": 1
                                          }
                                       }
                                    }
                                 }
                              ],
                              "len": 40,
                              "type": 4
                           }
                        },
                        {
                           "OFPInstructionActions": {
                              "actions": [
                                 {
                                    "OFPActionOutput": {
                                       "len": 16,
                                       "max_len": 65535,
                                       "port": 4294967293,
                                       "type": 0
                                    }
                                 }
                              ],
                              "len": 24,
                              "type": 3
                           }
                        }
                     ],
                     "length": 280,
                     "match": {
                        "OFPMatch": {
                           "length": 4,
                           "oxm_fields": [],
                           "type": 1
                        }
                     },
                     "packet_count": 1,
                     "priority": 0,
                     "table_id": 0
                  }
               }
            ],
            "flags": 0,
            "type": 1
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPAggregateStatsRequest`(datapath, flags, table_id, out_port, out_group, cookie, cookie_mask, match, type_=None)

  Aggregate flow statistics request message

  The controller uses this message to query aggregate flow statictics.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  table_id | ID of table to read
  out_port | Require matching entries to include this as an output port
  out_group | Require matching entries to include this as an output group
  cookie | Require matching entries to contain this cookie value
  cookie_mask | Mask used to restrict the cookie bits that must match
  match | Instance of `OFPMatch`

  Example:

      def send_aggregate_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          cookie = cookie_mask = 0
          match = ofp_parser.OFPMatch(in_port=1)
          req = ofp_parser.OFPAggregateStatsRequest(datapath, 0,
                                                    ofp.OFPTT_ALL,
                                                    ofp.OFPP_ANY,
                                                    ofp.OFPG_ANY,
                                                    cookie, cookie_mask,
                                                    match)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPAggregateStatsRequest": {
            "cookie": 0,
            "cookie_mask": 0,
            "flags": 0,
            "match": {
               "OFPMatch": {
                  "length": 4,
                  "oxm_fields": [],
                  "type": 1
               }
            },
            "out_group": 4294967295,
            "out_port": 4294967295,
            "table_id": 255,
            "type": 2
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPAggregateStatsReply`(datapath, type_=None, **kwargs)

  Aggregate flow statistics reply message

  The switch responds with this message to an aggregate flow statistics request.

  Attribute | Description
  --- | ---
  body | Instance of `OFPAggregateStats`

  Example:

      @set_ev_cls(ofp_event.EventOFPAggregateStatsReply, MAIN_DISPATCHER)
      def aggregate_stats_reply_handler(self, ev):
          body = ev.msg.body

          self.logger.debug('AggregateStats: packet_count=%d byte_count=%d '
                            'flow_count=%d',
                            body.packet_count, body.byte_count,
                            body.flow_count)

  JSON Example:

      {
         "OFPAggregateStatsReply": {
            "body": {
               "OFPAggregateStats": {
                  "byte_count": 574,
                  "flow_count": 6,
                  "packet_count": 7
               }
            },
            "flags": 0,
            "type": 2
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPTableStatsRequest`(datapath, flags=0, type_=None)

  Table statistics request message

  The controller uses this message to query flow table statictics.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_table_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPTableStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPTableStatsRequest": {
            "flags": 0,
            "type": 3
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPTableStatsReply`(datapath, type_=None, **kwargs)

  Table statistics reply message

  The switch responds with this message to a table statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPTableStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPTableStatsReply, MAIN_DISPATCHER)
      def table_stats_reply_handler(self, ev):
          tables = []
          for stat in ev.msg.body:
              tables.append('table_id=%d active_count=%d lookup_count=%d '
                            ' matched_count=%d' %
                            (stat.table_id, stat.active_count,
                             stat.lookup_count, stat.matched_count))
          self.logger.debug('TableStats: %s', tables)

  JSON Example:

      {
         "OFPTableStatsReply": {
            "body": [
               {
                  "OFPTableStats": {
                     "active_count": 4,
                     "lookup_count": 4,
                     "matched_count": 4,
                     "table_id": 0
                  }
               },
               {
                  "OFPTableStats": {
                     "active_count": 4,
                     "lookup_count": 4,
                     "matched_count": 4,
                     "table_id": 1
                  }
               }
            ],
            "flags": 0,
            "type": 3
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortStatsRequest`(datapath, flags=0, port_no=4294967295, type_=None)

  Port statistics request message

  The controller uses this message to query information about ports statistics.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  port_no | Port number to read (OFPP_ANY to all ports)

  Example:

      def send_port_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPPortStatsRequest(datapath, 0, ofp.OFPP_ANY)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPPortStatsRequest": {
            "flags": 0,
            "port_no": 4294967295,
            "type": 4
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortStatsReply`(datapath, type_=None, **kwargs)

  Port statistics reply message

  The switch responds with this message to a port statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPPortStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
      def port_stats_reply_handler(self, ev):
          ports = []
          for stat in ev.msg.body:
              ports.append('port_no=%d '
                           'rx_packets=%d tx_packets=%d '
                           'rx_bytes=%d tx_bytes=%d '
                           'rx_dropped=%d tx_dropped=%d '
                           'rx_errors=%d tx_errors=%d '
                           'rx_frame_err=%d rx_over_err=%d rx_crc_err=%d '
                           'collisions=%d duration_sec=%d duration_nsec=%d' %
                           (stat.port_no,
                            stat.rx_packets, stat.tx_packets,
                            stat.rx_bytes, stat.tx_bytes,
                            stat.rx_dropped, stat.tx_dropped,
                            stat.rx_errors, stat.tx_errors,
                            stat.rx_frame_err, stat.rx_over_err,
                            stat.rx_crc_err, stat.collisions,
                            stat.duration_sec, stat.duration_nsec))
          self.logger.debug('PortStats: %s', ports)

  JSON Example:

      {
         "OFPPortStatsReply": {
            "body": [
               {
                  "OFPPortStats": {
                     "collisions": 0,
                     "duration_nsec": 0,
                     "duration_sec": 0,
                     "port_no": 7,
                     "rx_bytes": 0,
                     "rx_crc_err": 0,
                     "rx_dropped": 0,
                     "rx_errors": 0,
                     "rx_frame_err": 0,
                     "rx_over_err": 0,
                     "rx_packets": 0,
                     "tx_bytes": 336,
                     "tx_dropped": 0,
                     "tx_errors": 0,
                     "tx_packets": 4
                  }
               },
               {
                  "OFPPortStats": {
                     "collisions": 0,
                     "duration_nsec": 0,
                     "duration_sec": 0,
                     "port_no": 6,
                     "rx_bytes": 336,
                     "rx_crc_err": 0,
                     "rx_dropped": 0,
                     "rx_errors": 0,
                     "rx_frame_err": 0,
                     "rx_over_err": 0,
                     "rx_packets": 4,
                     "tx_bytes": 336,
                     "tx_dropped": 0,
                     "tx_errors": 0,
                     "tx_packets": 4
                  }
               }
            ],
            "flags": 0,
            "type": 4
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortDescStatsRequest`(datapath, flags=0, type_=None)

  Port description request message

  The controller uses this message to query description of all the ports.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_port_desc_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPPortDescStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPPortDescStatsRequest": {
            "flags": 0,
            "type": 13
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortDescStatsReply`(datapath, type_=None, **kwargs)

  Port description reply message

  The switch responds with this message to a port description request.

  Attribute | Description
  --- | ---
  body | List of `OFPPort` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPPortDescStatsReply, MAIN_DISPATCHER)
      def port_desc_stats_reply_handler(self, ev):
          ports = []
          for p in ev.msg.body:
              ports.append('port_no=%d hw_addr=%s name=%s config=0x%08x '
                           'state=0x%08x curr=0x%08x advertised=0x%08x '
                           'supported=0x%08x peer=0x%08x curr_speed=%d '
                           'max_speed=%d' %
                           (p.port_no, p.hw_addr,
                            p.name, p.config,
                            p.state, p.curr, p.advertised,
                            p.supported, p.peer, p.curr_speed,
                            p.max_speed))
          self.logger.debug('OFPPortDescStatsReply received: %s', ports)

  JSON Example:

      {
         "OFPPortDescStatsReply": {
            "body": [
               {
                  "OFPPort": {
                     "advertised": 10240,
                     "config": 0,
                     "curr": 10248,
                     "curr_speed": 5000,
                     "hw_addr": "f2:0b:a4:d0:3f:70",
                     "max_speed": 5000,
                     "name": "Port7",
                     "peer": 10248,
                     "port_no": 7,
                     "state": 4,
                     "supported": 10248
                  }
               },
               {
                  "OFPPort": {
                     "advertised": 10240,
                     "config": 0,
                     "curr": 10248,
                     "curr_speed": 5000,
                     "hw_addr": "f2:0b:a4:7d:f8:ea",
                     "max_speed": 5000,
                     "name": "Port6",
                     "peer": 10248,
                     "port_no": 6,
                     "state": 4,
                     "supported": 10248
                  }
               }
            ],
            "flags": 0,
            "type": 13
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPQueueStatsRequest`(datapath, flags=0, port_no=4294967295, queue_id=4294967295, type_=None)

  Queue statistics request message

  The controller uses this message to query queue statictics.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  port_no | Port number to read
  queue_id | ID of queue to read

  Example:

      def send_queue_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPQueueStatsRequest(datapath, 0, ofp.OFPP_ANY,
                                                ofp.OFPQ_ALL)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPQueueStatsRequest": {
            "flags": 0,
            "port_no": 4294967295,
            "queue_id": 4294967295,
            "type": 5
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPQueueStatsReply`(datapath, type_=None, **kwargs)

  Queue statistics reply message

  The switch responds with this message to an aggregate flow statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPQueueStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPQueueStatsReply, MAIN_DISPATCHER)
      def queue_stats_reply_handler(self, ev):
          queues = []
          for stat in ev.msg.body:
              queues.append('port_no=%d queue_id=%d '
                            'tx_bytes=%d tx_packets=%d tx_errors=%d '
                            'duration_sec=%d duration_nsec=%d' %
                            (stat.port_no, stat.queue_id,
                             stat.tx_bytes, stat.tx_packets, stat.tx_errors,
                             stat.duration_sec, stat.duration_nsec))
          self.logger.debug('QueueStats: %s', queues)

  JSON Example:

      {
         "OFPQueueStatsReply": {
            "body": [
               {
                  "OFPQueueStats": {
                     "duration_nsec": 0,
                     "duration_sec": 0,
                     "port_no": 7,
                     "queue_id": 1,
                     "tx_bytes": 0,
                     "tx_errors": 0,
                     "tx_packets": 0
                  }
               },
               {
                  "OFPQueueStats": {
                     "duration_nsec": 0,
                     "duration_sec": 0,
                     "port_no": 6,
                     "queue_id": 1,
                     "tx_bytes": 0,
                     "tx_errors": 0,
                     "tx_packets": 0
                  }
               },
               {
                  "OFPQueueStats": {
                     "duration_nsec": 0,
                     "duration_sec": 0,
                     "port_no": 7,
                     "queue_id": 2,
                     "tx_bytes": 0,
                     "tx_errors": 0,
                     "tx_packets": 0
                  }
               }
            ],
            "flags": 0,
            "type": 5
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupStatsRequest`(datapath, flags=0, group_id=4294967292, type_=None)

  Group statistics request message

  The controller uses this message to query statistics of one or more groups.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  group_id | ID of group to read (OFPG_ALL to all groups)

  Example:

      def send_group_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPGroupStatsRequest(datapath, 0, ofp.OFPG_ALL)
          datapath.send_msg(req)

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupStatsReply`(datapath, type_=None, **kwargs)

  Group statistics reply message

  The switch responds with this message to a group statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPGroupStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPGroupStatsReply, MAIN_DISPATCHER)
      def group_stats_reply_handler(self, ev):
          groups = []
          for stat in ev.msg.body:
              groups.append('length=%d group_id=%d '
                            'ref_count=%d packet_count=%d byte_count=%d '
                            'duration_sec=%d duration_nsec=%d' %
                            (stat.length, stat.group_id,
                             stat.ref_count, stat.packet_count,
                             stat.byte_count, stat.duration_sec,
                             stat.duration_nsec))
          self.logger.debug('GroupStats: %s', groups)

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupDescStatsRequest`(datapath, flags=0, type_=None)

  Group description request message

  The controller uses this message to list the set of groups on a switch.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_group_desc_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPGroupDescStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPGroupDescStatsRequest": {
            "flags": 0,
            "type": 7
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupDescStatsReply`(datapath, type_=None, **kwargs)

  Group description reply message

  The switch responds with this message to a group description request.

  Attribute | Description
  --- | ---
  body | List of `OFPGroupDescStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPGroupDescStatsReply, MAIN_DISPATCHER)
      def group_desc_stats_reply_handler(self, ev):
          descs = []
          for stat in ev.msg.body:
              descs.append('length=%d type=%d group_id=%d '
                           'buckets=%s' %
                           (stat.length, stat.type, stat.group_id,
                            stat.bucket))
          self.logger.debug('GroupDescStats: %s', descs)

  JSON Example:

      {
         "OFPGroupDescStatsReply": {
            "body": [
               {
                  "OFPGroupDescStats": {
                     "buckets": [
                        {
                           "OFPBucket": {
                              "actions": [
                                 {
                                    "OFPActionOutput": {
                                       "len": 16,
                                       "max_len": 65535,
                                       "port": 2,
                                       "type": 0
                                    }
                                 }
                              ],
                              "len": 32,
                              "watch_group": 1,
                              "watch_port": 1,
                              "weight": 1
                           }
                        }
                     ],
                     "group_id": 1,
                     "length": 40,
                     "type": 0
                  }
               }
            ],
            "flags": 0,
            "type": 7
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupFeaturesStatsRequest`(datapath, flags=0, type_=None)

  Group features request message

  The controller uses this message to list the capabilities of groups on a switch.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_group_features_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPGroupFeaturesStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPGroupFeaturesStatsRequest": {
            "flags": 0,
            "type": 8
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGroupFeaturesStatsReply`(datapath, type_=None, **kwargs)

  Group features reply message

  The switch responds with this message to a group features request.

  Attribute | Description
  --- | ---
  body | Instance of `OFPGroupFeaturesStats`

  Example:

      @set_ev_cls(ofp_event.EventOFPGroupFeaturesStatsReply, MAIN_DISPATCHER)
      def group_features_stats_reply_handler(self, ev):
          body = ev.msg.body

          self.logger.debug('GroupFeaturesStats: types=%d '
                            'capabilities=0x%08x max_groups=%s '
                            'actions=%s',
                            body.types, body.capabilities,
                            body.max_groups, body.actions)

  JSON Example:

      {
         "OFPGroupFeaturesStatsReply": {
            "body": {
               "OFPGroupFeaturesStats": {
                  "actions": [
                     67082241,
                     67082241,
                     67082241,
                     67082241
                  ],
                  "capabilities": 5,
                  "max_groups": [
                     16777216,
                     16777216,
                     16777216,
                     16777216
                  ],
                  "types": 15
               }
            },
            "flags": 0,
            "type": 8
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterStatsRequest`(datapath, flags=0, meter_id=4294967295, type_=None)

  Meter statistics request message

  The controller uses this message to query statistics for one or more meters.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  meter_id | ID of meter to read (OFPM_ALL to all meters)

  Example:

      def send_meter_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPMeterStatsRequest(datapath, 0, ofp.OFPM_ALL)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPMeterStatsRequest": {
            "flags": 0,
            "meter_id": 4294967295,
            "type": 9
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterStatsReply`(datapath, type_=None, **kwargs)

  Meter statistics reply message

  The switch responds with this message to a meter statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPMeterStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPMeterStatsReply, MAIN_DISPATCHER)
      def meter_stats_reply_handler(self, ev):
          meters = []
          for stat in ev.msg.body:
              meters.append('meter_id=0x%08x len=%d flow_count=%d '
                            'packet_in_count=%d byte_in_count=%d '
                            'duration_sec=%d duration_nsec=%d '
                            'band_stats=%s' %
                            (stat.meter_id, stat.len, stat.flow_count,
                             stat.packet_in_count, stat.byte_in_count,
                             stat.duration_sec, stat.duration_nsec,
                             stat.band_stats))
          self.logger.debug('MeterStats: %s', meters)

  JSON Example:

      {
         "OFPMeterStatsReply": {
            "body": [
               {
                  "OFPMeterStats": {
                     "band_stats": [
                        {
                           "OFPMeterBandStats": {
                              "byte_band_count": 0,
                              "packet_band_count": 0
                           }
                        }
                     ],
                     "byte_in_count": 0,
                     "duration_nsec": 480000,
                     "duration_sec": 0,
                     "flow_count": 0,
                     "len": 56,
                     "meter_id": 100,
                     "packet_in_count": 0
                  }
               }
            ],
            "flags": 0,
            "type": 9
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterConfigStatsRequest`(datapath, flags=0, meter_id=4294967295, type_=None)

  Meter configuration statistics request message

  The controller uses this message to query configuration for one or more meters.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`
  meter_id | ID of meter to read (OFPM_ALL to all meters)

  Example:

      def send_meter_config_stats_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPMeterConfigStatsRequest(datapath, 0,
                                                      ofp.OFPM_ALL)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPMeterConfigStatsRequest": {
            "flags": 0,
            "meter_id": 4294967295,
            "type": 10
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterConfigStatsReply`(datapath, type_=None, **kwargs)

  Meter configuration statistics reply message

  The switch responds with this message to a meter configuration statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPMeterConfigStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPMeterConfigStatsReply, MAIN_DISPATCHER)
      def meter_config_stats_reply_handler(self, ev):
          configs = []
          for stat in ev.msg.body:
              configs.append('length=%d flags=0x%04x meter_id=0x%08x '
                             'bands=%s' %
                             (stat.length, stat.flags, stat.meter_id,
                              stat.bands))
          self.logger.debug('MeterConfigStats: %s', configs)

  JSON Example:

      {
         "OFPMeterConfigStatsReply": {
            "body": [
               {
                  "OFPMeterConfigStats": {
                     "bands": [
                        {
                           "OFPMeterBandDrop": {
                              "burst_size": 10,
                              "len": 16,
                              "rate": 1000,
                              "type": 1
                           }
                        }
                     ],
                     "flags": 14,
                     "length": 24,
                     "meter_id": 100
                  }
               }
            ],
            "flags": 0,
            "type": 10
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterFeaturesStatsRequest`(datapath, flags=0, type_=None)

  Meter features statistics request message

  The controller uses this message to query the set of features of the metering subsystem.

  Attribute | Description
  --- | ---
  flags | Zero or `OFPMPF_REQ_MORE`

  Example:

      def send_meter_features_stats_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPMeterFeaturesStatsRequest(datapath, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPMeterFeaturesStatsRequest": {
            "flags": 0,
            "type": 11
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMeterFeaturesStatsReply`(datapath, type_=None, **kwargs)

  Meter features statistics reply message

  The switch responds with this message to a meter features statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPMeterFeaturesStats` instance

  Example:

      @set_ev_cls(ofp_event.EventOFPMeterFeaturesStatsReply, MAIN_DISPATCHER)
      def meter_features_stats_reply_handler(self, ev):
          features = []
          for stat in ev.msg.body:
              features.append('max_meter=%d band_types=0x%08x '
                              'capabilities=0x%08x max_bands=%d '
                              'max_color=%d' %
                              (stat.max_meter, stat.band_types,
                               stat.capabilities, stat.max_bands,
                               stat.max_color))
          self.logger.debug('MeterFeaturesStats: %s', features)

  JSON Example:

      {
         "OFPMeterFeaturesStatsReply": {
            "body": [
               {
                  "OFPMeterFeaturesStats": {
                     "band_types": 2147483654,
                     "capabilities": 15,
                     "max_bands": 255,
                     "max_color": 0,
                     "max_meter": 16777216
                  }
               }
            ],
            "flags": 0,
            "type": 11
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPTableFeaturesStatsRequest`(datapath, flags=0, body=None, type_=None)

  Table features statistics request message

  The controller uses this message to query table features.

  Attribute | Description
  --- | ---
  body | List of `OFPTableFeaturesStats` instances. The default is [].

class `ryu.ofproto.ofproto_v1_3_parser.``OFPTableFeaturesStatsReply`(datapath, type_=None, **kwargs)

  Table features statistics reply message

  The switch responds with this message to a table features statistics request.

  Attribute | Description
  --- | ---
  body | List of `OFPTableFeaturesStats` instance

  JSON Example:

  > See an example in:

  > `ryu/tests/unit/ofproto/json/of13/4-56-ofp_table_features_reply.packet.json`

### Queue Configuration Messages

class `ryu.ofproto.ofproto_v1_3_parser.``OFPQueueGetConfigRequest`(datapath, port)

  Queue configuration request message

  Attribute | Description
  --- | ---
  port | Port to be queried (OFPP_ANY to all configured queues)

  Example:

      def send_queue_get_config_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPQueueGetConfigRequest(datapath, ofp.OFPP_ANY)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPQueueGetConfigRequest": {
            "port": 4294967295
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPQueueGetConfigReply`(datapath, queues=None, port=None)

  Queue configuration reply message

  The switch responds with this message to a queue configuration request.

  Attribute | Description
  --- | ---
  queues | list of `OFPPacketQueue` instance
  port | Port which was queried

  Example:

      @set_ev_cls(ofp_event.EventOFPQueueGetConfigReply, MAIN_DISPATCHER)
      def queue_get_config_reply_handler(self, ev):
          msg = ev.msg

          self.logger.debug('OFPQueueGetConfigReply received: '
                            'port=%s queues=%s',
                            msg.port, msg.queues)

  JSON Example:

      {
         "OFPQueueGetConfigReply": {
            "port": 4294967295,
            "queues": [
               {
                  "OFPPacketQueue": {
                     "len": 64,
                     "port": 77,
                     "properties": [
                        {
                           "OFPQueuePropMinRate": {
                              "len": 16,
                              "property": 1,
                              "rate": 10
                           }
                        },
                        {
                           "OFPQueuePropMaxRate": {
                              "len": 16,
                              "property": 2,
                              "rate": 900
                           }
                        },
                        {
                           "OFPQueuePropExperimenter": {
                              "data": [],
                              "experimenter": 999,
                              "len": 16,
                              "property": 65535
                           }
                        }
                     ],
                     "queue_id": 99
                  }
               },
               {
                  "OFPPacketQueue": {
                     "len": 65,
                     "port": 77,
                     "properties": [
                        {
                           "OFPQueuePropMinRate": {
                              "len": 16,
                              "property": 1,
                              "rate": 100
                           }
                        },
                        {
                           "OFPQueuePropMaxRate": {
                              "len": 16,
                              "property": 2,
                              "rate": 200
                           }
                        },
                        {
                           "OFPQueuePropExperimenter": {
                              "experimenter": 999,
                              "data": [
                                 1
                              ],
                              "len": 17,
                              "property": 65535
                           }
                        }
                     ],
                     "queue_id": 88
                  }
               },
               {
                  "OFPPacketQueue": {
                     "len": 66,
                     "port": 77,
                     "properties": [
                        {
                           "OFPQueuePropMinRate": {
                              "len": 16,
                              "property": 1,
                              "rate": 200
                           }
                        },
                        {
                           "OFPQueuePropMaxRate": {
                              "len": 16,
                              "property": 2,
                              "rate": 400
                           }
                        },
                        {
                           "OFPQueuePropExperimenter": {
                              "experimenter": 999,
                              "data": [
                                 1,
                                 2
                              ],
                              "len": 18,
                              "property": 65535
                           }
                        }
                     ],
                     "queue_id": 77
                  }
               }
            ]
         }
      }

### Packet-Out Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPacketOut`(datapath, buffer_id=None, in_port=None, actions=None, data=None, actions_len=None)

  Packet-Out message

  The controller uses this message to send a packet out throught the switch.

  Attribute | Description
  --- | ---
  buffer_id | ID assigned by datapath (OFP_NO_BUFFER if none)
  in_port | Packet’s input port or `OFPP_CONTROLLER`
  actions | list of OpenFlow action class
  data | Packet data

  Example:

      def send_packet_out(self, datapath, buffer_id, in_port):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD, 0)]
          req = ofp_parser.OFPPacketOut(datapath, buffer_id,
                                        in_port, actions)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPPacketOut": {
            "actions": [
               {
                  "OFPActionOutput": {
                     "len": 16,
                     "max_len": 65535,
                     "port": 4294967292,
                     "type": 0
                  }
               }
            ],
            "actions_len": 16,
            "buffer_id": 4294967295,
            "data": "8guk0D9w8gukffjqCABFAABU+BoAAP8Br4sKAAABCgAAAggAAgj3YAAAMdYCAAAAAACrjS0xAAAAABAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vAAAAAAAAAAA=",
            "in_port": 4294967293
         }
      }

### Barrier Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPBarrierRequest`(datapath)

  Barrier request message

  The controller sends this message to ensure message dependencies have been met or receive notifications for completed operations.

  Example:

      def send_barrier_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPBarrierRequest(datapath)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPBarrierRequest": {}
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPBarrierReply`(datapath)

  Barrier reply message

  The switch responds with this message to a barrier request.

  Example:

      @set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER)
      def barrier_reply_handler(self, ev):
          self.logger.debug('OFPBarrierReply received')

  JSON Example:

      {
         "OFPBarrierReply": {}
      }

### Role Request Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPRoleRequest`(datapath, role=None, generation_id=None)

  Role request message

  The controller uses this message to change its role.

  Attribute | Description
  --- | ---
  role | One of the following values. OFPCR_ROLE_NOCHANGE OFPCR_ROLE_EQUAL OFPCR_ROLE_MASTER OFPCR_ROLE_SLAVE
  generation_id | Master Election Generation ID

  Example:

      def send_role_request(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPRoleRequest(datapath, ofp.OFPCR_ROLE_EQUAL, 0)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPRoleRequest": {
            "generation_id": 17294086455919964160,
            "role": 2
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPRoleReply`(datapath, role=None, generation_id=None)

  Role reply message

  The switch responds with this message to a role request.

  Attribute | Description
  --- | ---
  role | One of the following values. OFPCR_ROLE_NOCHANGE OFPCR_ROLE_EQUAL OFPCR_ROLE_MASTER OFPCR_ROLE_SLAVE
  generation_id | Master Election Generation ID

  Example:

      @set_ev_cls(ofp_event.EventOFPRoleReply, MAIN_DISPATCHER)
      def role_reply_handler(self, ev):
          msg = ev.msg
          dp = msg.datapath
          ofp = dp.ofproto

          if msg.role == ofp.OFPCR_ROLE_NOCHANGE:
              role = 'NOCHANGE'
          elif msg.role == ofp.OFPCR_ROLE_EQUAL:
              role = 'EQUAL'
          elif msg.role == ofp.OFPCR_ROLE_MASTER:
              role = 'MASTER'
          elif msg.role == ofp.OFPCR_ROLE_SLAVE:
              role = 'SLAVE'
          else:
              role = 'unknown'

          self.logger.debug('OFPRoleReply received: '
                            'role=%s generation_id=%d',
                            role, msg.generation_id)

  JSON Example:

      {
         "OFPRoleReply": {
            "generation_id": 17294086455919964160,
            "role": 3
         }
      }

### Set Asynchronous Configuration Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPSetAsync`(datapath, packet_in_mask, port_status_mask, flow_removed_mask)

  Set asynchronous configuration message

  The controller sends this message to set the asynchronous messages that it wants to receive on a given OpneFlow channel.

  Attribute | Description
  --- | ---
  packet_in_mask | 2-element array: element 0, when the controller has a OFPCR_ROLE_EQUAL or OFPCR_ROLE_MASTER role. element 1, OFPCR_ROLE_SLAVE role controller. Bitmasks of following values. OFPR_NO_MATCH OFPR_ACTION OFPR_INVALID_TTL
  port_status_mask | 2-element array. Bitmasks of following values. OFPPR_ADD OFPPR_DELETE OFPPR_MODIFY
  flow_removed_mask | 2-element array. Bitmasks of following values. OFPRR_IDLE_TIMEOUT OFPRR_HARD_TIMEOUT OFPRR_DELETE OFPRR_GROUP_DELETE

  Example:

      def send_set_async(self, datapath):
          ofp = datapath.ofproto
          ofp_parser = datapath.ofproto_parser

          packet_in_mask = ofp.OFPR_ACTION | ofp.OFPR_INVALID_TTL
          port_status_mask = (ofp.OFPPR_ADD | ofp.OFPPR_DELETE |
                              ofp.OFPPR_MODIFY)
          flow_removed_mask = (ofp.OFPRR_IDLE_TIMEOUT |
                               ofp.OFPRR_HARD_TIMEOUT |
                               ofp.OFPRR_DELETE)
          req = ofp_parser.OFPSetAsync(datapath,
                                       [packet_in_mask, 0],
                                       [port_status_mask, 0],
                                       [flow_removed_mask, 0])
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPSetAsync": {
            "flow_removed_mask": [
               15,
               3
            ],
            "packet_in_mask": [
               5,
               1
            ],
            "port_status_mask": [
               7,
               3
            ]
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGetAsyncRequest`(datapath)

  Get asynchronous configuration request message

  The controller uses this message to query the asynchronous message.

  Example:

      def send_get_async_request(self, datapath):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPGetAsyncRequest(datapath)
          datapath.send_msg(req)

  JSON Example:

      {
         "OFPGetAsyncRequest": {}
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPGetAsyncReply`(datapath, packet_in_mask=None, port_status_mask=None, flow_removed_mask=None)

  Get asynchronous configuration reply message

  The switch responds with this message to a get asynchronous configuration request.

  Attribute | Description
  --- | ---
  packet_in_mask | 2-element array: element 0, when the controller has a OFPCR_ROLE_EQUAL or OFPCR_ROLE_MASTER role. element 1, OFPCR_ROLE_SLAVE role controller. Bitmasks of following values. OFPR_NO_MATCH OFPR_ACTION OFPR_INVALID_TTL
  port_status_mask | 2-element array. Bitmasks of following values. OFPPR_ADD OFPPR_DELETE OFPPR_MODIFY
  flow_removed_mask | 2-element array. Bitmasks of following values. OFPRR_IDLE_TIMEOUT OFPRR_HARD_TIMEOUT OFPRR_DELETE OFPRR_GROUP_DELETE

  Example:

      @set_ev_cls(ofp_event.EventOFPGetAsyncReply, MAIN_DISPATCHER)
      def get_async_reply_handler(self, ev):
          msg = ev.msg

          self.logger.debug('OFPGetAsyncReply received: '
                            'packet_in_mask=0x%08x:0x%08x '
                            'port_status_mask=0x%08x:0x%08x '
                            'flow_removed_mask=0x%08x:0x%08x',
                            msg.packet_in_mask[0],
                            msg.packet_in_mask[1],
                            msg.port_status_mask[0],
                            msg.port_status_mask[1],
                            msg.flow_removed_mask[0],
                            msg.flow_removed_mask[1])

  JSON Example:

      {
         "OFPGetAsyncReply": {
            "flow_removed_mask": [
               15,
               3
            ],
            "packet_in_mask": [
               5,
               1
            ],
            "port_status_mask": [
               7,
               3
            ]
         }
      }

## Asynchronous Messages

### Packet-In Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPacketIn`(datapath, buffer_id=None, total_len=None, reason=None, table_id=None, cookie=None, match=None, data=None)

  Packet-In message

  The switch sends the packet that received to the controller by this message.

  Attribute | Description
  --- | ---
  buffer_id | ID assigned by datapath
  total_len | Full length of frame
  reason | Reason packet is being sent. OFPR_NO_MATCH OFPR_ACTION OFPR_INVALID_TTL
  table_id | ID of the table that was looked up
  cookie | Cookie of the flow entry that was looked up
  match | Instance of `OFPMatch`
  data | Ethernet frame

  Example:

      @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
      def packet_in_handler(self, ev):
          msg = ev.msg
          dp = msg.datapath
          ofp = dp.ofproto

          if msg.reason == ofp.OFPR_NO_MATCH:
              reason = 'NO MATCH'
          elif msg.reason == ofp.OFPR_ACTION:
              reason = 'ACTION'
          elif msg.reason == ofp.OFPR_INVALID_TTL:
              reason = 'INVALID TTL'
          else:
              reason = 'unknown'

          self.logger.debug('OFPPacketIn received: '
                            'buffer_id=%x total_len=%d reason=%s '
                            'table_id=%d cookie=%d match=%s data=%s',
                            msg.buffer_id, msg.total_len, reason,
                            msg.table_id, msg.cookie, msg.match,
                            utils.hex_array(msg.data))

  JSON Example:

      {
         "OFPPacketIn": {
            "buffer_id": 2,
            "cookie": 283686884868096,
            "data": "////////8gukffjqCAYAAQgABgQAAfILpH346goAAAEAAAAAAAAKAAAD",
            "match": {
               "OFPMatch": {
                  "length": 80,
                  "oxm_fields": [
                     {
                        "OXMTlv": {
                           "field": "in_port",
                           "mask": null,
                           "value": 6
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "eth_type",
                           "mask": null,
                           "value": 2054
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "eth_dst",
                           "mask": null,
                           "value": "ff:ff:ff:ff:ff:ff"
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "eth_src",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "arp_op",
                           "mask": null,
                           "value": 1
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "arp_spa",
                           "mask": null,
                           "value": "10.0.0.1"
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "arp_tpa",
                           "mask": null,
                           "value": "10.0.0.3"
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "arp_sha",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     },
                     {
                        "OXMTlv": {
                           "field": "arp_tha",
                           "mask": null,
                           "value": "00:00:00:00:00:00"
                        }
                     }
                  ],
                  "type": 1
               }
            },
            "reason": 1,
            "table_id": 1,
            "total_len": 42
         }
      }

### Flow Removed Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPFlowRemoved`(datapath, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None)

  Flow removed message

  When flow entries time out or are deleted, the switch notifies controller with this message.

  Attribute | Description
  --- | ---
  cookie | Opaque controller-issued identifier
  priority | Priority level of flow entry
  reason | One of the following values. OFPRR_IDLE_TIMEOUT OFPRR_HARD_TIMEOUT OFPRR_DELETE OFPRR_GROUP_DELETE
  table_id | ID of the table
  duration_sec | Time flow was alive in seconds
  duration_nsec | Time flow was alive in nanoseconds beyond duration_sec
  idle_timeout | Idle timeout from original flow mod
  hard_timeout | Hard timeout from original flow mod
  packet_count | Number of packets that was associated with the flow
  byte_count | Number of bytes that was associated with the flow
  match | Instance of `OFPMatch`

  Example:

      @set_ev_cls(ofp_event.EventOFPFlowRemoved, MAIN_DISPATCHER)
      def flow_removed_handler(self, ev):
          msg = ev.msg
          dp = msg.datapath
          ofp = dp.ofproto

          if msg.reason == ofp.OFPRR_IDLE_TIMEOUT:
              reason = 'IDLE TIMEOUT'
          elif msg.reason == ofp.OFPRR_HARD_TIMEOUT:
              reason = 'HARD TIMEOUT'
          elif msg.reason == ofp.OFPRR_DELETE:
              reason = 'DELETE'
          elif msg.reason == ofp.OFPRR_GROUP_DELETE:
              reason = 'GROUP DELETE'
          else:
              reason = 'unknown'

          self.logger.debug('OFPFlowRemoved received: '
                            'cookie=%d priority=%d reason=%s table_id=%d '
                            'duration_sec=%d duration_nsec=%d '
                            'idle_timeout=%d hard_timeout=%d '
                            'packet_count=%d byte_count=%d match.fields=%s',
                            msg.cookie, msg.priority, reason, msg.table_id,
                            msg.duration_sec, msg.duration_nsec,
                            msg.idle_timeout, msg.hard_timeout,
                            msg.packet_count, msg.byte_count, msg.match)

  JSON Example:

      {
         "OFPFlowRemoved": {
            "byte_count": 86,
            "cookie": 0,
            "duration_nsec": 48825000,
            "duration_sec": 3,
            "hard_timeout": 0,
            "idle_timeout": 3,
            "match": {
               "OFPMatch": {
                  "length": 14,
                  "oxm_fields": [
                     {
                        "OXMTlv": {
                           "field": "eth_dst",
                           "mask": null,
                           "value": "f2:0b:a4:7d:f8:ea"
                        }
                     }
                  ],
                  "type": 1
               }
            },
            "packet_count": 1,
            "priority": 65535,
            "reason": 0,
            "table_id": 0
         }
      }

### Port Status Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPortStatus`(datapath, reason=None, desc=None)

  Port status message

  The switch notifies controller of change of ports.

  Attribute | Description
  --- | ---
  reason | One of the following values. OFPPR_ADD OFPPR_DELETE OFPPR_MODIFY
  desc | instance of `OFPPort`

  Example:

      @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER)
      def port_status_handler(self, ev):
          msg = ev.msg
          dp = msg.datapath
          ofp = dp.ofproto

          if msg.reason == ofp.OFPPR_ADD:
              reason = 'ADD'
          elif msg.reason == ofp.OFPPR_DELETE:
              reason = 'DELETE'
          elif msg.reason == ofp.OFPPR_MODIFY:
              reason = 'MODIFY'
          else:
              reason = 'unknown'

          self.logger.debug('OFPPortStatus received: reason=%s desc=%s',
                            reason, msg.desc)

  JSON Example:

      {
         "OFPPortStatus": {
            "desc": {
               "OFPPort": {
                  "advertised": 10240,
                  "config": 0,
                  "curr": 10248,
                  "curr_speed": 5000,
                  "hw_addr": "f2:0b:a4:d0:3f:70",
                  "max_speed": 5000,
                  "name": "\u79c1\u306e\u30dd\u30fc\u30c8",
                  "peer": 10248,
                  "port_no": 7,
                  "state": 4,
                  "supported": 10248
               }
            },
            "reason": 0
         }
      }

### Error Message

class `ryu.ofproto.ofproto_v1_3_parser.``OFPErrorMsg`(datapath, type_=None, code=None, data=None)

  Error message

  The switch notifies controller of problems by this message.

  Attribute | Description
  --- | ---
  type | High level type of error
  code | Details depending on the type
  data | Variable length data depending on the type and code

  `type` attribute corresponds to `type_` parameter of __init__.

  Types and codes are defined in `ryu.ofproto.ofproto`.

  Type | Code
  --- | ---
  OFPET_HELLO_FAILED | OFPHFC_*
  OFPET_BAD_REQUEST | OFPBRC_*
  OFPET_BAD_ACTION | OFPBAC_*
  OFPET_BAD_INSTRUCTION | OFPBIC_*
  OFPET_BAD_MATCH | OFPBMC_*
  OFPET_FLOW_MOD_FAILED | OFPFMFC_*
  OFPET_GROUP_MOD_FAILED | OFPGMFC_*
  OFPET_PORT_MOD_FAILED | OFPPMFC_*
  OFPET_TABLE_MOD_FAILED | OFPTMFC_*
  OFPET_QUEUE_OP_FAILED | OFPQOFC_*
  OFPET_SWITCH_CONFIG_FAILED | OFPSCFC_*
  OFPET_ROLE_REQUEST_FAILED | OFPRRFC_*
  OFPET_METER_MOD_FAILED | OFPMMFC_*
  OFPET_TABLE_FEATURES_FAILED | OFPTFFC_*
  OFPET_EXPERIMENTER | N/A

  Example:

      @set_ev_cls(ofp_event.EventOFPErrorMsg,
                  [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
      def error_msg_handler(self, ev):
          msg = ev.msg

          self.logger.debug('OFPErrorMsg received: type=0x%02x code=0x%02x '
                            'message=%s',
                            msg.type, msg.code, utils.hex_array(msg.data))

  JSON Example:

      {
         "OFPErrorMsg": {
            "code": 11,
            "data": "ZnVnYWZ1Z2E=",
            "type": 2
         }
      }

## Symmetric Messages

### Hello

class `ryu.ofproto.ofproto_v1_3_parser.``OFPHello`(datapath, elements=None)

  Hello message

  When connection is started, the hello message is exchanged between a switch and a controller.

  This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

  Attribute | Description
  --- | ---
  elements | list of `OFPHelloElemVersionBitmap` instance

  JSON Example:

      {
         "OFPHello": {
            "elements": [
               {
                  "OFPHelloElemVersionBitmap": {
                     "length": 8,
                     "type": 1,
                     "versions": [
                        1,
                        2,
                        3,
                        9,
                        10,
                        30
                     ]
                  }
               }
            ]
         }
      }

class `ryu.ofproto.ofproto_v1_3_parser.``OFPHelloElemVersionBitmap`(versions, type_=None, length=None)

  Version bitmap Hello Element

  Attribute | Description
  --- | ---
  versions | list of versions of OpenFlow protocol a device supports

### Echo Request

class `ryu.ofproto.ofproto_v1_3_parser.``OFPEchoRequest`(datapath, data=None)

  Echo request message

  This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

  Attribute | Description
  --- | ---
  data | An arbitrary length data

  Example:

      def send_echo_request(self, datapath, data):
          ofp_parser = datapath.ofproto_parser

          req = ofp_parser.OFPEchoRequest(datapath, data)
          datapath.send_msg(req)

      @set_ev_cls(ofp_event.EventOFPEchoRequest,
                  [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
      def echo_request_handler(self, ev):
          self.logger.debug('OFPEchoRequest received: data=%s',
                            utils.hex_array(ev.msg.data))

  JSON Example:

      {
         "OFPEchoRequest": {
            "data": "aG9nZQ=="
         }
      }

### Echo Reply

class `ryu.ofproto.ofproto_v1_3_parser.``OFPEchoReply`(datapath, data=None)

  Echo reply message

  This message is handled by the Ryu framework, so the Ryu application do not need to process this typically.

  Attribute | Description
  --- | ---
  data | An arbitrary length data

  Example:

      def send_echo_reply(self, datapath, data):
          ofp_parser = datapath.ofproto_parser

          reply = ofp_parser.OFPEchoReply(datapath, data)
          datapath.send_msg(reply)

      @set_ev_cls(ofp_event.EventOFPEchoReply,
                  [HANDSHAKE_DISPATCHER, CONFIG_DISPATCHER, MAIN_DISPATCHER])
      def echo_reply_handler(self, ev):
          self.logger.debug('OFPEchoReply received: data=%s',
                            utils.hex_array(ev.msg.data))

  JSON Example:

      {
         "OFPEchoReply": {
            "data": "aG9nZQ=="
         }
      }

### Experimenter

class `ryu.ofproto.ofproto_v1_3_parser.``OFPExperimenter`(datapath, experimenter=None, exp_type=None, data=None)

  Experimenter extension message

  Attribute | Description
  --- | ---
  experimenter | Experimenter ID
  exp_type | Experimenter defined
  data | Experimenter defined arbitrary additional data

  JSON Example:

      {
         "OFPExperimenter": {
            "data": "bmF6bw==",
            "exp_type": 123456789,
            "experimenter": 98765432
         }
      }

## Port Structures

class `ryu.ofproto.ofproto_v1_3_parser.``OFPPort`

  Description of a port

  Attribute | Description
  --- | ---
  port_no | Port number and it uniquely identifies a port within a switch.
  hw_addr | MAC address for the port.
  name | Null-terminated string containing a human-readable name for the interface.
  config | Bitmap of port configration flags. OFPPC_PORT_DOWN OFPPC_NO_RECV OFPPC_NO_FWD OFPPC_NO_PACKET_IN
  state | Bitmap of port state flags. OFPPS_LINK_DOWN OFPPS_BLOCKED OFPPS_LIVE
  curr | Current features.
  advertised | Features being advertised by the port.
  supported | Features supported by the port.
  peer | Features advertised by peer.
  curr_speed | Current port bitrate in kbps.
  max_speed | Max port bitrate in kbps.

## Flow Match Structure

class `ryu.ofproto.ofproto_v1_3_parser.``OFPMatch`(type_=None, length=None, _ordered_fields=None, **kwargs)

  Flow Match Structure

  This class is implementation of the flow match structure having compose/query API. There are new API and old API for compatibility. the old API is supposed to be removed later.

  You can define the flow match by the keyword arguments. The following arguments are available.

  Argument | Value | Description
  --- | --- | ---
  in_port | Integer 32bit | Switch input port
  in_phy_port | Integer 32bit | Switch physical input port
  metadata | Integer 64bit | Metadata passed between tables
  eth_dst | MAC address | Ethernet destination address
  eth_src | MAC address | Ethernet source address
  eth_type | Integer 16bit | Ethernet frame type
  vlan_vid | Integer 16bit | VLAN id
  vlan_pcp | Integer 8bit | VLAN priority
  ip_dscp | Integer 8bit | IP DSCP (6 bits in ToS field)
  ip_ecn | Integer 8bit | IP ECN (2 bits in ToS field)
  ip_proto | Integer 8bit | IP protocol
  ipv4_src | IPv4 address | IPv4 source address
  ipv4_dst | IPv4 address | IPv4 destination address
  tcp_src | Integer 16bit | TCP source port
  tcp_dst | Integer 16bit | TCP destination port
  udp_src | Integer 16bit | UDP source port
  udp_dst | Integer 16bit | UDP destination port
  sctp_src | Integer 16bit | SCTP source port
  sctp_dst | Integer 16bit | SCTP destination port
  icmpv4_type | Integer 8bit | ICMP type
  icmpv4_code | Integer 8bit | ICMP code
  arp_op | Integer 16bit | ARP opcode
  arp_spa | IPv4 address | ARP source IPv4 address
  arp_tpa | IPv4 address | ARP target IPv4 address
  arp_sha | MAC address | ARP source hardware address
  arp_tha | MAC address | ARP target hardware address
  ipv6_src | IPv6 address | IPv6 source address
  ipv6_dst | IPv6 address | IPv6 destination address
  ipv6_flabel | Integer 32bit | IPv6 Flow Label
  icmpv6_type | Integer 8bit | ICMPv6 type
  icmpv6_code | Integer 8bit | ICMPv6 code
  ipv6_nd_target | IPv6 address | Target address for ND
  ipv6_nd_sll | MAC address | Source link-layer for ND
  ipv6_nd_tll | MAC address | Target link-layer for ND
  mpls_label | Integer 32bit | MPLS label
  mpls_tc | Integer 8bit | MPLS TC
  mpls_bos | Integer 8bit | MPLS BoS bit
  pbb_isid | Integer 24bit | PBB I-SID
  tunnel_id | Integer 64bit | Logical Port Metadata
  ipv6_exthdr | Integer 16bit | IPv6 Extension Header pseudo-field
  pbb_uca | Integer 8bit | PBB UCA header field (EXT-256 Old version of ONF Extension)
  tcp_flags | Integer 16bit | TCP flags (EXT-109 ONF Extension)
  actset_output | Integer 32bit | Output port from action set metadata (EXT-233 ONF Extension)

  Example:

      >>> # compose
      >>> match = parser.OFPMatch(
      ...     in_port=1,
      ...     eth_type=0x86dd,
      ...     ipv6_src=('2001:db8:bd05:1d2:288a:1fc0:1:10ee',
      ...               'ffff:ffff:ffff:ffff::'),
      ...     ipv6_dst='2001:db8:bd05:1d2:288a:1fc0:1:10ee')
      >>> # query
      >>> if 'ipv6_src' in match:
      ...     print match['ipv6_src']
      ...
      ('2001:db8:bd05:1d2:288a:1fc0:1:10ee', 'ffff:ffff:ffff:ffff::')

  Note

  For the list of the supported Nicira experimenter matches, please refer to ryu.ofproto.nx_match.

  Note

  For VLAN id match field, special values are defined in OpenFlow Spec.

  1. Packets with and without a VLAN tag

     > - Example:

     >       match = parser.OFPMatch()

     > - Packet Matching

     >   > non-VLAN-tagged | MATCH
     >   > VLAN-tagged(vlan_id=3) | MATCH
     >   > VLAN-tagged(vlan_id=5) | MATCH

  2. Only packets without a VLAN tag

     > - Example:

     >       match = parser.OFPMatch(vlan_vid=0x0000)

     > - Packet Matching

     >   > non-VLAN-tagged | MATCH
     >   > VLAN-tagged(vlan_id=3) | x
     >   > VLAN-tagged(vlan_id=5) | x

  3. Only packets with a VLAN tag regardless of its value

     > - Example:

     >       match = parser.OFPMatch(vlan_vid=(0x1000, 0x1000))

     > - Packet Matching

     >   > non-VLAN-tagged | x
     >   > VLAN-tagged(vlan_id=3) | MATCH
     >   > VLAN-tagged(vlan_id=5) | MATCH

  4. Only packets with VLAN tag and VID equal

     > - Example:

     >       match = parser.OFPMatch(vlan_vid=(0x1000 | 3))

     > - Packet Matching

     >   > non-VLAN-tagged | x
     >   > VLAN-tagged(vlan_id=3) | MATCH
     >   > VLAN-tagged(vlan_id=5) | x

## Flow Instruction Structures

class `ryu.ofproto.ofproto_v1_3_parser.``OFPInstructionGotoTable`(table_id, type_=None, len_=None)

  Goto table instruction

  This instruction indicates the next table in the processing pipeline.

  Attribute | Description
  --- | ---
  table_id | Next table

class `ryu.ofproto.ofproto_v1_3_parser.``OFPInstructionWriteMetadata`(metadata, metadata_mask, type_=None, len_=None)

  Write metadata instruction

  This instruction writes the masked metadata value into the metadata field.

  Attribute | Description
  --- | ---
  metadata | Metadata value to write
  metadata_mask | Metadata write bitmask

class `ryu.ofproto.ofproto_v1_3_parser.``OFPInstructionActions`(type_, actions=None, len_=None)

  Actions instruction

  This instruction writes/applies/clears the actions.

  Attribute | Description
  --- | ---
  type | One of following values. OFPIT_WRITE_ACTIONS OFPIT_APPLY_ACTIONS OFPIT_CLEAR_ACTIONS
  actions | list of OpenFlow action class

  `type` attribute corresponds to `type_` parameter of __init__.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPInstructionMeter`(meter_id=1, type_=None, len_=None)

  Meter instruction

  This instruction applies the meter.

  Attribute | Description
  --- | ---
  meter_id | Meter instance

## Action Structures

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionOutput`(port, max_len=65509, type_=None, len_=None)

  Output action

  This action indicates output a packet to the switch port.

  Attribute | Description
  --- | ---
  port | Output port
  max_len | Max length to send to controller

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionGroup`(group_id=0, type_=None, len_=None)

  Group action

  This action indicates the group used to process the packet.

  Attribute | Description
  --- | ---
  group_id | Group identifier

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionSetQueue`(queue_id, type_=None, len_=None)

  Set queue action

  This action sets the queue id that will be used to map a flow to an already-configured queue on a port.

  Attribute | Description
  --- | ---
  queue_id | Queue ID for the packets

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionSetMplsTtl`(mpls_ttl, type_=None, len_=None)

  Set MPLS TTL action

  This action sets the MPLS TTL.

  Attribute | Description
  --- | ---
  mpls_ttl | MPLS TTL

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionDecMplsTtl`(type_=None, len_=None)

  Decrement MPLS TTL action

  This action decrements the MPLS TTL.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionSetNwTtl`(nw_ttl, type_=None, len_=None)

  Set IP TTL action

  This action sets the IP TTL.

  Attribute | Description
  --- | ---
  nw_ttl | IP TTL

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionDecNwTtl`(type_=None, len_=None)

  Decrement IP TTL action

  This action decrements the IP TTL.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionCopyTtlOut`(type_=None, len_=None)

  Copy TTL Out action

  This action copies the TTL from the next-to-outermost header with TTL to the outermost header with TTL.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionCopyTtlIn`(type_=None, len_=None)

  Copy TTL In action

  This action copies the TTL from the outermost header with TTL to the next-to-outermost header with TTL.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionPushVlan`(ethertype=33024, type_=None, len_=None)

  Push VLAN action

  This action pushes a new VLAN tag to the packet.

  Attribute | Description
  --- | ---
  ethertype | Ether type. The default is 802.1Q. (0x8100)

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionPushMpls`(ethertype=34887, type_=None, len_=None)

  Push MPLS action

  This action pushes a new MPLS header to the packet.

  Attribute | Description
  --- | ---
  ethertype | Ether type

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionPopVlan`(type_=None, len_=None)

  Pop VLAN action

  This action pops the outermost VLAN tag from the packet.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionPopMpls`(ethertype=2048, type_=None, len_=None)

  Pop MPLS action

  This action pops the MPLS header from the packet.

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionSetField`(field=None, **kwargs)

  Set field action

  This action modifies a header field in the packet.

  The set of keywords available for this is same as OFPMatch.

  Example:

      set_field = OFPActionSetField(eth_src="00:00:00:00:00:00")

class `ryu.ofproto.ofproto_v1_3_parser.``OFPActionExperimenter`(experimenter)

  Experimenter action

  This action is an extensible action for the experimenter.

  Attribute | Description
  --- | ---
  experimenter | Experimenter ID

  Note

  For the list of the supported Nicira experimenter actions, please refer to ryu.ofproto.nx_actions.