OpenFlow v1.0 消息和结构

控制器到交换机消息

握手

class os_ken.ofproto.ofproto_v1_0_parser.OFPFeaturesRequest(datapath)

功能请求消息

控制器在会话建立后向交换机发送功能请求。

此消息由 OSKen 框架处理，因此 OSKen 应用程序通常不需要处理此消息。

示例

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

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

JSON 示例

{
   "OFPFeaturesRequest": {}
}

class os_ken.ofproto.ofproto_v1_0_parser.OFPSwitchFeatures(datapath, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, actions=None, ports=None)

功能回复消息

交换机响应功能请求，发送功能回复消息。

此消息由 OSKen 框架处理，因此 OSKen 应用程序通常不需要处理此消息。

属性	描述
datapath_id	数据通路唯一 ID。
n_buffers	一次最多可以缓冲的包数。
n_tables	数据通路支持的表数量。
capabilities	能力标志的位图。 OFPC_FLOW_STATS OFPC_TABLE_STATS OFPC_PORT_STATS OFPC_STP OFPC_RESERVED OFPC_IP_REASM OFPC_QUEUE_STATS OFPC_ARP_MATCH_IP
动作	支持的 OFPAT_* 的位图。
ports	OFPPhyPort 实例列表。

示例

@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 capabilities=0x%08x ports=%s',
                      msg.datapath_id, msg.n_buffers, msg.n_tables,
                      msg.capabilities, msg.ports)

JSON 示例

{
   "OFPSwitchFeatures": {
      "actions": 2115,
      "capabilities": 169,
      "datapath_id": 1095522080376,
      "n_buffers": 0,
      "n_tables": 255,
      "ports": {
         "6": {
            "OFPPhyPort": {
               "advertised": 640,
               "config": 0,
               "curr": 648,
               "hw_addr": "f2:0b:a4:7d:f8:ea",
               "name": "Port6",
               "peer": 648,
               "port_no": 6,
               "state": 2,
               "supported": 648
            }
         },
         "7": {
            "OFPPhyPort": {
               "advertised": 640,
               "config": 0,
               "curr": 648,
               "hw_addr": "f2:0b:a4:d0:3f:70",
               "name": "Port7",
               "peer": 648,
               "port_no": 7,
               "state": 16,
               "supported": 648
            }
         }
      }
   }
}

交换机配置

class os_ken.ofproto.ofproto_v1_0_parser.OFPSetConfig(datapath, flags=None, miss_send_len=None)

设置配置请求消息

控制器发送设置配置请求消息以设置配置参数。

属性	描述
flags	以下配置标志之一。 OFPC_FRAG_NORMAL OFPC_FRAG_DROP OFPC_FRAG_REASM OFPC_FRAG_MASK
miss_send_len	数据通路应发送到控制器的新的流的最大字节数。

示例

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)

class os_ken.ofproto.ofproto_v1_0_parser.OFPGetConfigRequest(datapath)

获取配置请求消息

控制器发送获取配置请求以查询交换机中的配置参数。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPGetConfigReply(datapath)

获取配置回复消息

交换机响应配置请求，发送获取配置回复消息。

属性	描述
flags	以下配置标志之一。 OFPC_FRAG_NORMAL OFPC_FRAG_DROP OFPC_FRAG_REASM OFPC_FRAG_MASK
miss_send_len	数据通路应发送到控制器的新的流的最大字节数。

示例

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

    if msg.flags == ofp.OFPC_FRAG_NORMAL:
        flags = 'NORMAL'
    elif msg.flags == ofp.OFPC_FRAG_DROP:
        flags = 'DROP'
    elif msg.flags == ofp.OFPC_FRAG_REASM:
        flags = 'REASM'
    elif msg.flags == ofp.OFPC_FRAG_MASK:
        flags = 'MASK'
    else:
        flags = 'unknown'
    self.logger.debug('OFPGetConfigReply received: '
                      'flags=%s miss_send_len=%d',
                      flags, msg.miss_send_len)

修改状态消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPFlowMod(datapath, match=None, cookie=0, command=0, idle_timeout=0, hard_timeout=0, priority=32768, buffer_id=4294967295, out_port=65535, flags=0, actions=None)

修改流条目消息

控制器发送此消息以修改流表。

属性	描述
match	OFPMatch 实例。
cookie	不透明的控制器颁发的标识符。
command	以下值之一。 OFPFC_ADD OFPFC_MODIFY OFPFC_MODIFY_STRICT OFPFC_DELETE OFPFC_DELETE_STRICT
idle_timeout	空闲时间后丢弃（秒）。
hard_timeout	最大时间后丢弃（秒）。
priority	流条目的优先级。
buffer_id	要应用的缓冲包（或 0xffffffff）。对于 OFPFC_DELETE* 无意义。
out_port	对于 OFPFC_DELETE* 命令，要求匹配的条目包含此作为输出端口。OFPP_NONE 的值表示没有限制。
flags	以下值之一。 OFPFF_SEND_FLOW_REM OFPFF_CHECK_OVERLAP OFPFF_EMERG
动作	OFPAction* 实例列表。

示例

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

    match = ofp_parser.OFPMatch(in_port=1)
    cookie = 0
    command = ofp.OFPFC_ADD
    idle_timeout = hard_timeout = 0
    priority = 32768
    buffer_id = 0xffffffff
    out_port = ofproto.OFPP_NONE
    flags = 0
    actions = [ofp_parser.OFPActionOutput(ofp.OFPP_NORMAL, 0)]
    req = ofp_parser.OFPFlowMod(
        datapath, match, cookie, command, idle_timeout, hard_timeout,
        priority, buffer_id, out_port, flags, actions)
    datapath.send_msg(req)

JSON 示例

{
   "OFPFlowMod": {
      "actions": [
         {
            "OFPActionOutput": {
               "max_len": 65535,
               "port": 6
            }
         }
      ],
      "buffer_id": 65535,
      "command": 0,
      "cookie": 0,
      "flags": 0,
      "hard_timeout": 0,
      "idle_timeout": 0,
      "match": {
         "OFPMatch": {
            "dl_dst": "f2:0b:a4:7d:f8:ea",
            "dl_src": "00:00:00:00:00:00",
            "dl_type": 0,
            "dl_vlan": 0,
            "dl_vlan_pcp": 0,
            "in_port": 0,
            "nw_dst": "0.0.0.0",
            "nw_proto": 0,
            "nw_src": "0.0.0.0",
            "nw_tos": 0,
            "tp_dst": 0,
            "tp_src": 0,
            "wildcards": 4194295
         }
      },
      "out_port": 65532,
      "priority": 123
   }
}

class os_ken.ofproto.ofproto_v1_0_parser.OFPPortMod(datapath, port_no=0, hw_addr='00:00:00:00:00:00', config=0, mask=0, advertise=0)

端口修改消息

控制器发送此消息以修改端口的行为。

属性	描述
port_no	要修改的端口号。
hw_addr	硬件地址必须与 OFPSwitchFeatures 的 OFPPhyPort 的 hw_addr 相同。
config	配置标志的位图。 OFPPC_PORT_DOWN OFPPC_NO_STP OFPPC_NO_RECV OFPPC_NO_RECV_STP OFPPC_NO_FLOOD OFPPC_NO_FWD OFPPC_NO_PACKET_IN
mask	要更改的上述配置标志的位图
advertise	以下标志的位图。 OFPPF_10MB_HD OFPPF_10MB_FD OFPPF_100MB_HD OFPPF_100MB_FD OFPPF_1GB_HD OFPPF_1GB_FD OFPPF_10GB_FD OFPPF_COPPER OFPPF_FIBER OFPPF_AUTONEG OFPPF_PAUSE OFPPF_PAUSE_ASYM

示例

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)

队列配置消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPQueueGetConfigRequest(datapath, port)

队列配置请求消息

属性	描述
port	要查询的端口。应引用有效的物理端口（即 < OFPP_MAX）。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPQueueGetConfigReply(datapath)

队列配置回复消息

交换机通过此消息响应队列配置请求。

属性	描述
port	要查询的端口。
queues	OFPPacketQueue 实例列表。

示例

@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)

读取状态消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPDescStatsRequest(datapath, flags)

描述统计请求消息

控制器使用此消息查询交换机的描述。

属性	描述
flags	零（规范中尚未定义）。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPDescStatsReply(datapath)

描述统计回复消息

交换机使用包含此消息的统计回复来响应描述统计请求。

属性	描述
mfr_desc	制造商描述。
hw_desc	硬件描述。
sw_desc	软件描述。
serial_num	序列号。
dp_desc	数据通路的易读描述。

示例

@set_ev_cls(ofp_event.EventOFPDescStatsReply, MAIN_DISPATCHER)
def desc_stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    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)

class os_ken.ofproto.ofproto_v1_0_parser.OFPFlowStatsRequest(datapath, flags, match, table_id, out_port)

单个流统计请求消息

控制器使用此消息查询单个流统计信息。

属性	描述
flags	零（规范中尚未定义）。
match	OFPMatch 实例。
table_id	要读取的表的 ID（来自 ofp_table_stats），0xff 表示所有表，0xfe 表示紧急情况。
out_port	要求匹配的条目包含此作为输出端口。OFPP_NONE 的值表示没有限制。

示例

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

    match = ofp_parser.OFPMatch(in_port=1)
    table_id = 0xff
    out_port = ofp.OFPP_NONE
    req = ofp_parser.OFPFlowStatsRequest(
        datapath, 0, match, table_id, out_port)

    datapath.send_msg(req)

class os_ken.ofproto.ofproto_v1_0_parser.OFPFlowStatsReply(datapath)

单个流统计回复消息

交换机使用包含此消息的统计回复来响应单个流统计请求。

属性	描述
table_id	流来自的表 ID。
match	OFPMatch 实例。
duration_sec	流存活的时间（秒）。
duration_nsec	超出 duration_sec 的流存活的时间（纳秒）。
priority	条目的优先级。仅当这不是精确匹配条目时才有意义。
idle_timeout	到期前的空闲秒数。
hard_timeout	到期前的秒数。
cookie	不透明的控制器颁发的标识符。
packet_count	流中的包数。
byte_count	流中的字节数。
动作	OFPAction* 实例列表

示例

@set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER)
def flow_stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    body = ev.msg.body

    flows = []
    for stat in body:
        flows.append('table_id=%s match=%s '
                     'duration_sec=%d duration_nsec=%d '
                     'priority=%d '
                     'idle_timeout=%d hard_timeout=%d '
                     'cookie=%d packet_count=%d byte_count=%d '
                     'actions=%s' %
                     (stat.table_id, stat.match,
                      stat.duration_sec, stat.duration_nsec,
                      stat.priority,
                      stat.idle_timeout, stat.hard_timeout,
                      stat.cookie, stat.packet_count, stat.byte_count,
                      stat.actions))
    self.logger.debug('FlowStats: %s', flows)

class os_ken.ofproto.ofproto_v1_0_parser.OFPAggregateStatsRequest(datapath, flags, match, table_id, out_port)

聚合流统计请求消息

控制器使用此消息查询聚合流统计信息。

属性	描述
flags	零（规范中尚未定义）。
match	要匹配的字段。
table_id	要读取的表的 ID（来自 ofp_table_stats）0xff 表示所有表，0xfe 表示紧急情况。
out_port	要求匹配的条目包含此作为输出端口。OFPP_NONE 的值表示没有限制。

示例

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, match, 0xff, ofp.OFPP_NONE)

    datapath.send_msg(req)

class os_ken.ofproto.ofproto_v1_0_parser.OFPAggregateStatsReply(datapath)

聚合流统计回复消息

交换机使用包含此消息的统计回复来响应聚合流统计请求。

属性	描述
packet_count	流中的包数。
byte_count	流中的字节数。
flow_count	流的数量。

示例

@set_ev_cls(ofp_event.EventOFPAggregateStatsReply, MAIN_DISPATCHER)
def aggregate_stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    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)

class os_ken.ofproto.ofproto_v1_0_parser.OFPTableStatsRequest(datapath, flags)

表统计请求消息

控制器使用此消息查询流表统计信息。

属性	描述
flags	零（规范中尚未定义）。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPTableStatsReply(datapath)

表统计回复消息

交换机使用包含此消息的统计回复来响应表统计请求。

属性	描述
table_id	表 ID。
name	表名称。
wildcards	表支持的 OFPFW_* 通配符的位图。
max_entries	支持的最大条目数
active_count	活动条目数
lookup_count	在表中查找的包数
matched_count	命中表的包数

示例

@set_ev_cls(ofp_event.EventOFPTableStatsReply, MAIN_DISPATCHER)
def stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    body = ev.msg.body

    tables = []
    for stat in body:
        tables.append('table_id=%d name=%s wildcards=0x%02x '
                      'max_entries=%d active_count=%d '
                      'lookup_count=%d matched_count=%d' %
                      (stat.table_id, stat.name, stat.wildcards,
                       stat.max_entries, stat.active_count,
                       stat.lookup_count, stat.matched_count))
    self.logger.debug('TableStats: %s', tables)

class os_ken.ofproto.ofproto_v1_0_parser.OFPPortStatsRequest(datapath, flags, port_no)

端口统计请求消息

控制器使用此消息查询端口统计信息。

属性	描述
flags	零（规范中尚未定义）。
port_no	要读取的端口号（OFPP_NONE 表示所有端口）。

示例

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)

class os_ken.ofproto.ofproto_v1_0_parser.OFPPortStatsReply(datapath)

端口统计回复消息

交换机使用包含此消息的统计回复来响应端口统计请求。

属性	描述
port_no	端口号。
rx_packets	接收到的包数。
tx_packets	发送的包数。
rx_bytes	接收到的字节数。
tx_bytes	发送的字节数。
rx_dropped	RX 丢弃的包数。
tx_dropped	TX 丢弃的包数。
rx_errors	接收错误数。
tx_errors	发送错误数。
rx_frame_err	帧对齐错误数。
rx_over_err	RX 溢出的包数。
rx_crc_err	CRC 错误数。
collisions	碰撞次数。

示例

@set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
def port_stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    body = ev.msg.body

    ports = []
    for stat in 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' %
                     (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))
    self.logger.debug('PortStats: %s', ports)

class os_ken.ofproto.ofproto_v1_0_parser.OFPQueueStatsRequest(datapath, flags, port_no, queue_id)

队列统计请求消息

控制器使用此消息查询队列统计信息。

属性	描述
flags	零（规范中尚未定义）。
port_no	要读取的端口号（如果为 OFPT_ALL，则表示所有端口）。
queue_id	要读取的队列 ID（如果为 OFPQ_ALL，则表示所有队列）。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPQueueStatsReply(datapath)

队列统计回复消息

交换机使用包含此消息的统计回复来响应聚合流统计请求。

属性	描述
port_no	端口号。
queue_id	队列 ID。
tx_bytes	发送的字节数。
tx_packets	发送的包数。
tx_errors	因拥塞而丢弃的数据包数量。

示例

@set_ev_cls(ofp_event.EventOFPQueueStatsReply, MAIN_DISPATCHER)
def stats_reply_handler(self, ev):
    msg = ev.msg
    ofp = msg.datapath.ofproto
    body = ev.msg.body

    queues = []
    for stat in body:
        queues.append('port_no=%d queue_id=%d '
                      'tx_bytes=%d tx_packets=%d tx_errors=%d ' %
                      (stat.port_no, stat.queue_id,
                       stat.tx_bytes, stat.tx_packets, stat.tx_errors))
    self.logger.debug('QueueStats: %s', queues)

class os_ken.ofproto.ofproto_v1_0_parser.OFPVendorStatsRequest(datapath, flags, vendor, specific_data=None)

厂商统计请求消息

控制器使用此消息查询交换机的厂商特定信息。

class os_ken.ofproto.ofproto_v1_0_parser.OFPVendorStatsReply(datapath)

厂商统计回复消息

交换机使用包含此消息的统计回复来响应厂商统计请求。

发送数据包消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPPacketOut(datapath, buffer_id=None, in_port=None, actions=None, data=None)

报文输出消息

控制器使用此消息通过交换机发送一个报文。

属性	描述
buffer_id	由 datapath 分配的 ID（如果没有，则为 0xffffffff）。
in_port	数据包的输入端口（如果没有，则为 OFPP_NONE）。
动作	OFPAction* 实例的列表。
data	二进制类型值的报文数据或 packet.Packet 的实例。

示例

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

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

JSON 示例

{
   "OFPPacketOut": {
      "actions": [
         {
            "OFPActionOutput": {
               "max_len": 65535,
               "port": 65532
            }
         }
      ],
      "buffer_id": 4294967295,
      "data": "8guk0D9w8gukffjqCABFAABU+BoAAP8Br4sKAAABCgAAAggAAgj3YAAAMdYCAAAAAACrjS0xAAAAABAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vAAAAAAAAAAA=",
      "in_port": 65533
   }
}

屏障消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPBarrierRequest(datapath)

屏障请求消息

控制器发送此消息以确保已满足消息依赖关系或接收已完成操作的通知。

示例

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

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

class os_ken.ofproto.ofproto_v1_0_parser.OFPBarrierReply(datapath)

屏障回复消息

交换机用此消息响应屏障请求。

示例

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

异步消息

报文输入消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPPacketIn(datapath, buffer_id=None, total_len=None, in_port=None, reason=None, data=None)

报文输入消息

交换机通过此消息将接收到的报文发送给控制器。

属性	描述
buffer_id	由 datapath 分配的 ID。
total_len	帧的完整长度。
in_port	接收帧的端口。
reason	发送报文的原因。 OFPR_NO_MATCH OFPR_ACTION OFPR_INVALID_TTL
data	以太网帧。

示例

@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 in_port=%d, '
                      'reason=%s data=%s',
                      msg.buffer_id, msg.total_len, msg.in_port,
                      reason, utils.hex_array(msg.data))

JSON 示例

{
   "OFPPacketIn": {
      "buffer_id": 2,
      "data": "////////8gukffjqCAYAAQgABgQAAfILpH346goAAAEAAAAAAAAKAAAD",
      "in_port": 99,
      "reason": 1,
      "total_len": 42
   }
}

流移除消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPFlowRemoved(datapath)

流移除消息

当流条目超时或被删除时，交换机通过此消息通知控制器。

属性	描述
match	OFPMatch 实例。
cookie	不透明的控制器颁发的标识符。
priority	流条目的优先级。
reason	以下值之一。 OFPRR_IDLE_TIMEOUT OFPRR_HARD_TIMEOUT OFPRR_DELETE
duration_sec	流存活的时间，以秒为单位。
duration_nsec	超出 duration_sec 的纳秒时间。
idle_timeout	原始流 mod 的空闲超时。
packet_count	与流关联的数据包数量。
byte_count	与流关联的字节数。

示例

@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: '
                      'match=%s cookie=%d priority=%d reason=%s '
                      'duration_sec=%d duration_nsec=%d '
                      'idle_timeout=%d packet_count=%d byte_count=%d',
                      msg.match, msg.cookie, msg.priority, reason,
                      msg.duration_sec, msg.duration_nsec,
                      msg.idle_timeout, msg.packet_count,
                      msg.byte_count)

端口状态消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPPortStatus(datapath, reason=None, desc=None)

端口状态消息

交换机通知控制器端口的变化。

属性	描述
reason	以下值之一。 OFPPR_ADD OFPPR_DELETE OFPPR_MODIFY
desc	OFPPhyPort 的实例

示例

@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)

错误消息

class os_ken.ofproto.ofproto_v1_0_parser.OFPErrorMsg(datapath, type_=None, code=None, data=None)

错误消息

交换机通过此消息通知控制器问题。

属性	描述
type	错误的高级类型
code	根据类型而定的详细信息
data	根据类型和代码而定的变长数据

type 属性对应于 __init__ 的 type_ 参数。

类型和代码在 os_ken.ofproto.ofproto 中定义。

类型	代码
OFPET_HELLO_FAILED	OFPHFC_*
OFPET_BAD_REQUEST	OFPBRC_*
OFPET_BAD_ACTION	OFPBAC_*
OFPET_FLOW_MOD_FAILED	OFPFMFC_*
OFPET_PORT_MOD_FAILED	OFPPMFC_*
OFPET_QUEUE_OP_FAILED	OFPQOFC_*

示例

@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))

对称消息

Hello

class os_ken.ofproto.ofproto_v1_0_parser.OFPHello(datapath)

Hello 消息

当连接启动时，Hello 消息在交换机和控制器之间交换。

此消息由 OSKen 框架处理，因此 OSKen 应用程序通常不需要处理此消息。

Echo 请求

class os_ken.ofproto.ofproto_v1_0_parser.OFPEchoRequest(datapath, data=None)

Echo 请求消息

此消息由 OSKen 框架处理，因此 OSKen 应用程序通常不需要处理此消息。

属性	描述
data	任意长度的数据。

示例

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

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

Echo 响应

class os_ken.ofproto.ofproto_v1_0_parser.OFPEchoReply(datapath, data=None)

Echo 响应消息

此消息由 OSKen 框架处理，因此 OSKen 应用程序通常不需要处理此消息。

属性	描述
data	任意长度的数据。

示例

@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))

厂商

class os_ken.ofproto.ofproto_v1_0_parser.OFPVendor(datapath)

厂商消息

控制器发送此消息将厂商特定的信息发送到交换机。

端口结构

class os_ken.ofproto.ofproto_v1_0_parser.OFPPhyPort(port_no, hw_addr, name, config, state, curr, advertised, supported, peer)

端口的描述

属性	描述
port_no	端口号，它在交换机内唯一标识一个端口。
hw_addr	端口的 MAC 地址。
name	以 null 结尾的字符串，包含接口的可读名称。
config	端口配置标志的位图。 OFPPC_PORT_DOWN OFPPC_NO_STP OFPPC_NO_RECV OFPPC_NO_RECV_STP OFPPC_NO_FLOOD OFPPC_NO_FWD OFPPC_NO_PACKET_IN
state	端口状态标志的位图。 OFPPS_LINK_DOWN OFPPS_STP_LISTEN OFPPS_STP_LEARN OFPPS_STP_FORWARD OFPPS_STP_BLOCK OFPPS_STP_MASK
curr	当前功能。
advertised	端口正在广播的功能。
支持	端口支持的功能。
peer	对端广播的功能。

流匹配结构

class os_ken.ofproto.ofproto_v1_0_parser.OFPMatch(wildcards=None, in_port=None, dl_src=None, dl_dst=None, dl_vlan=None, dl_vlan_pcp=None, dl_type=None, nw_tos=None, nw_proto=None, nw_src=None, nw_dst=None, tp_src=None, tp_dst=None, nw_src_mask=32, nw_dst_mask=32)

流匹配结构

此类是具有 compose/query API 的流匹配结构的实现。

属性	描述
wildcards	通配字段。
(匹配字段)	有关可用匹配字段，请参阅以下内容。

参数	值	描述
in_port	整数 16 位	交换机输入端口。
dl_src	MAC 地址	以太网源地址。
dl_dst	MAC 地址	以太网目标地址。
dl_vlan	整数 16 位	输入 VLAN ID。
dl_vlan_pcp	整数 8 位	输入 VLAN 优先级。
dl_type	整数 16 位	以太网帧类型。
nw_tos	整数 8 位	IP ToS（实际上是 DSCP 字段，6 位）。
nw_proto	整数 8 位	IP 协议或 ARP 操作码的低 8 位。
nw_src	IPv4 地址	IP 源地址。
nw_dst	IPv4 地址	IP 目标地址。
tp_src	整数 16 位	TCP/UDP 源端口。
tp_dst	整数 16 位	TCP/UDP 目标端口。
nw_src_mask	整数 8 位	IP 源地址掩码，指定为 IPv4 地址前缀。
nw_dst_mask	整数 8 位	IP 目标地址掩码，指定为 IPv4 地址前缀。

示例

>>> # compose
>>> match = parser.OFPMatch(
...     in_port=1,
...     dl_type=0x0800,
...     dl_src='aa:bb:cc:dd:ee:ff',
...     nw_src='192.168.0.1')
>>> # query
>>> if 'nw_src' in match:
...     print match['nw_src']
...
'192.168.0.1'

动作结构

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionHeader(type_, len_)

class os_ken.ofproto.ofproto_v1_0_parser.OFPAction

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionOutput(port, max_len=65509)

输出动作

此动作指示将数据包输出到交换机端口。

属性	描述
port	输出端口。
max_len	发送到控制器的最大长度。

注意：

这个魔术数字 (0xffe5) 的原因是 of1.0 中没有好的常量。使用了与 of1.2 和 of1.3 的 OFPCML_MAX 相同的值。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionVlanVid(vlan_vid)

设置 802.1q VLAN ID 操作

此操作指示要设置的 802.1q VLAN ID。

属性	描述
vlan_vid	VLAN ID。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionVlanPcp(vlan_pcp)

设置 802.1q 优先级操作

此操作指示要设置的 802.1q 优先级。

属性	描述
vlan_pcp	VLAN 优先级。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionStripVlan

移除 802.1q 标头操作

此操作指示要移除 802.1q 优先级。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionDlAddr(dl_addr)

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetDlSrc(dl_addr)

设置以太网源地址动作

此动作指示要设置的以太网源地址。

属性	描述
dl_addr	以太网地址。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetDlDst(dl_addr)

设置以太网目标地址动作

此动作指示要设置的以太网目标地址。

属性	描述
dl_addr	以太网地址。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionNwAddr(nw_addr)

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetNwSrc(nw_addr)

设置IP源地址动作

此动作指示要设置的IP源地址。

属性	描述
nw_addr	IP地址。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetNwDst(nw_addr)

设置IP目标地址动作

此动作指示要设置的IP目标地址。

属性	描述
nw_addr	IP地址。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetNwTos(tos)

设置IP ToS动作

此动作指示要设置的IP ToS（DSCP字段，6位）。

属性	描述
tos	IP ToS（DSCP字段，6位）。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionTpPort(tp)

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetTpSrc(tp)

设置TCP/UDP源端口动作

此动作指示要设置的TCP/UDP源端口。

属性	描述
tp	TCP/UDP端口。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionSetTpDst(tp)

设置TCP/UDP目标端口动作

此动作指示要设置的TCP/UDP目标端口。

属性	描述
tp	TCP/UDP端口。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionEnqueue(port, queue_id)

输出到队列动作

此动作指示将数据包发送到端口上的给定队列。

属性	描述
port	队列所属端口。
queue_id	将数据包入队的地点。

class os_ken.ofproto.ofproto_v1_0_parser.OFPActionVendor(vendor=None)

厂商动作

此动作是厂商的可扩展动作。