| ## This file is part of Scapy |
| ## See http://www.secdev.org/projects/scapy for more information |
| ## Copyright (C) Philippe Biondi <phil@secdev.org> |
| ## This program is published under a GPLv2 license |
| |
| ## Copyright (C) 2014 Maxence Tury <maxence.tury@ssi.gouv.fr> |
| ## OpenFlow is an open standard used in SDN deployments. |
| ## Based on OpenFlow v1.0.1 |
| ## Specifications can be retrieved from https://www.opennetworking.org/ |
| |
| # scapy.contrib.description = Openflow v1.0 |
| # scapy.contrib.status = loads |
| |
| from __future__ import absolute_import |
| import struct |
| from scapy.fields import * |
| from scapy.layers.l2 import * |
| from scapy.layers.inet import * |
| from scapy.compat import orb |
| |
| ### If prereq_autocomplete is True then match prerequisites will be |
| ### automatically handled. See OFPMatch class. |
| prereq_autocomplete = False |
| |
| ##################################################### |
| ################# Predefined values ################# |
| ##################################################### |
| |
| ofp_port_no = { 0xfff8: "IN_PORT", |
| 0xfff9: "TABLE", |
| 0xfffa: "NORMAL", |
| 0xfffb: "FLOOD", |
| 0xfffc: "ALL", |
| 0xfffd: "CONTROLLER", |
| 0xfffe: "LOCAL", |
| 0xffff: "NONE" } |
| |
| ofp_table = { 0xff: "ALL" } |
| |
| ofp_queue = { 0xffffffff: "ALL" } |
| |
| ofp_buffer = { 0xffffffff: "NO_BUFFER" } |
| |
| ofp_max_len = { 0xffff: "NO_BUFFER" } |
| |
| ##################################################### |
| ################# Common structures ################# |
| ##################################################### |
| |
| ### The following structures will be used in different types |
| ### of OpenFlow messages: ports, matches, actions, queues. |
| |
| |
| ##################### Ports ##################### |
| |
| ofp_port_config = [ "PORT_DOWN", |
| "NO_STP", |
| "NO_RECV", |
| "NO_RECV_STP", |
| "NO_FLOOD", |
| "NO_FWD", |
| "NO_PACKET_IN" ] |
| |
| ofp_port_state = [ "LINK_DOWN" ] |
| |
| ofp_port_state_stp = { 0: "OFPPS_STP_LISTEN", |
| 1: "OFPPS_STP_LEARN", |
| 2: "OFPPS_STP_FORWARD", |
| 3: "OFPPS_STP_BLOCK" } |
| |
| ofp_port_features = [ "10MB_HD", |
| "10MB_FD", |
| "100MB_HD", |
| "100MB_FD", |
| "1GB_HD", |
| "1GB_FD", |
| "10GB_FD", |
| "COPPER", |
| "FIBER", |
| "AUTONEG", |
| "PAUSE", |
| "PAUSE_ASYM" ] |
| |
| class OFPPhyPort(Packet): |
| name = "OFP_PHY_PORT" |
| fields_desc = [ ShortEnumField("port_no", 0, ofp_port_no), |
| MACField("hw_addr", "0"), |
| StrFixedLenField("port_name", "", 16), |
| FlagsField("config", 0, 32, ofp_port_config), |
| BitEnumField("stp_state", 0, 24, ofp_port_state), |
| FlagsField("state", 0, 8, ofp_port_state), |
| FlagsField("curr", 0, 32, ofp_port_features), |
| FlagsField("advertised", 0, 32, ofp_port_features), |
| FlagsField("supported", 0, 32, ofp_port_features), |
| FlagsField("peer", 0, 32, ofp_port_features) ] |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| class OFPMatch(Packet): |
| name = "OFP_MATCH" |
| fields_desc= [ FlagsField("wildcards1", None, 12, [ "DL_VLAN_PCP", |
| "NW_TOS" ]), |
| BitField("nw_dst_mask", None, 6), |
| BitField("nw_src_mask", None, 6), |
| FlagsField("wildcards2", None, 8, [ "IN_PORT", |
| "DL_VLAN", |
| "DL_SRC", |
| "DL_DST", |
| "DL_TYPE", |
| "NW_PROTO", |
| "TP_SRC", |
| "TP_DST" ]), |
| ShortEnumField("in_port", None, ofp_port_no), |
| MACField("dl_src", None), |
| MACField("dl_dst", None), |
| ShortField("dl_vlan", None), |
| ByteField("dl_vlan_pcp", None), |
| XByteField("pad1", None), |
| ShortField("dl_type", None), |
| ByteField("nw_tos", None), |
| ByteField("nw_proto", None), |
| XShortField("pad2", None), |
| IPField("nw_src", "0"), |
| IPField("nw_dst", "0"), |
| ShortField("tp_src", None), |
| ShortField("tp_dst", None) ] |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| ### with post_build we create the wildcards field bit by bit |
| def post_build(self, p, pay): |
| # first 10 bits of an ofp_match are always set to 0 |
| l = "0"*10 |
| |
| # when one field has not been declared, it is assumed to be wildcarded |
| if self.wildcards1 is None: |
| if self.nw_tos is None: l+="1" |
| else: l+="0" |
| if self.dl_vlan_pcp is None: l+="1" |
| else: l+="0" |
| else: |
| w1 = binrepr(self.wildcards1) |
| l+="0"*(2-len(w1)) |
| l+=w1 |
| |
| # ip masks use 6 bits each |
| if self.nw_dst_mask is None: |
| if self.nw_dst is "0": l+="111111" |
| # 0x100000 would be ok too (32-bit IP mask) |
| else: l+="0"*6 |
| else: |
| m1 = binrepr(self.nw_dst_mask) |
| l+="0"*(6-len(m1)) |
| l+=m1 |
| if self.nw_src_mask is None: |
| if self.nw_src is "0": l+="111111" |
| else: l+="0"*6 |
| else: |
| m2 = binrepr(self.nw_src_mask) |
| l+="0"*(6-len(m2)) |
| l+=m2 |
| |
| # wildcards2 works the same way as wildcards1 |
| if self.wildcards2 is None: |
| if self.tp_dst is None: l+="1" |
| else: l+="0" |
| if self.tp_src is None: l+="1" |
| else: l+="0" |
| if self.nw_proto is None: l+="1" |
| else: l+="0" |
| if self.dl_type is None: l+="1" |
| else: l+="0" |
| if self.dl_dst is None: l+="1" |
| else: l+="0" |
| if self.dl_src is None: l+="1" |
| else: l+="0" |
| if self.dl_vlan is None: l+="1" |
| else: l+="0" |
| if self.in_port is None: l+="1" |
| else: l+="0" |
| else: |
| w2 = binrepr(self.wildcards2) |
| l+="0"*(8-len(w2)) |
| l+=w2 |
| |
| ### In order to write OFPMatch compliant with the specifications, |
| ### if prereq_autocomplete has been set to True |
| ### we assume ethertype=IP or nwproto=TCP when appropriate subfields are provided. |
| if prereq_autocomplete: |
| if self.dl_type is None: |
| if self.nw_src is not "0" or self.nw_dst is not "0" or self.nw_proto is not None or self.nw_tos is not None: |
| p = p[:22] + struct.pack("!H", 0x0800) + p[24:] |
| l = l[:-5] + "0" + l[-4:] |
| if self.nw_proto is None: |
| if self.tp_src is not None or self.tp_dst is not None: |
| p = p[:22] + struct.pack("!H", 0x0800) + p[24:] |
| l = l[:-5] + "0" + l[-4:] |
| p = p[:25] + struct.pack("!B", 0x06) + p[26:] |
| l = l[:-6] + "0" + l[-5:] |
| |
| ins = b"".join(chb(int("".join(x),2)) for x in zip(*[iter(l)]*8)) |
| p = ins + p[4:] |
| return p + pay |
| |
| |
| ###################### Actions ###################### |
| |
| class _ofp_action_header(Packet): |
| name = "Dummy OpenFlow Action Header" |
| |
| def post_build(self, p, pay): |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| return p + pay |
| |
| ofp_action_types = { 0: "OFPAT_OUTPUT", |
| 1: "OFPAT_SET_VLAN_VID", |
| 2: "OFPAT_SET_VLAN_PCP", |
| 3: "OFPAT_STRIP_VLAN", |
| 4: "OFPAT_SET_DL_SRC", |
| 5: "OFPAT_SET_DL_DST", |
| 6: "OFPAT_SET_NW_SRC", |
| 7: "OFPAT_SET_NW_DST", |
| 8: "OFPAT_SET_NW_TOS", |
| 9: "OFPAT_SET_TP_SRC", |
| 10: "OFPAT_SET_TP_DST", |
| 11: "OFPAT_ENQUEUE", |
| 65535: "OFPAT_VENDOR" } |
| |
| class OFPATOutput(_ofp_action_header): |
| name = "OFPAT_OUTPUT" |
| fields_desc = [ ShortEnumField("type", 0, ofp_action_types), |
| ShortField("len", 8), |
| ShortEnumField("port", 0, ofp_port_no), |
| ShortEnumField("max_len", "NO_BUFFER", ofp_max_len) ] |
| |
| class OFPATSetVLANVID(_ofp_action_header): |
| name = "OFPAT_SET_VLAN_VID" |
| fields_desc = [ ShortEnumField("type", 1, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("vlan_vid", 0), |
| XShortField("pad", 0) ] |
| |
| class OFPATSetVLANPCP(_ofp_action_header): |
| name = "OFPAT_SET_VLAN_PCP" |
| fields_desc = [ ShortEnumField("type", 2, ofp_action_types), |
| ShortField("len", 8), |
| ByteField("vlan_pcp", 0), |
| X3BytesField("pad", 0) ] |
| |
| class OFPATStripVLAN(_ofp_action_header): |
| name = "OFPAT_STRIP_VLAN" |
| fields_desc = [ ShortEnumField("type", 3, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATSetDlSrc(_ofp_action_header): |
| name = "OFPAT_SET_DL_SRC" |
| fields_desc = [ ShortEnumField("type", 4, ofp_action_types), |
| ShortField("len", 16), |
| MACField("dl_addr", "0"), |
| XBitField("pad", 0, 48) ] |
| |
| class OFPATSetDlDst(_ofp_action_header): |
| name = "OFPAT_SET_DL_DST" |
| fields_desc = [ ShortEnumField("type", 5, ofp_action_types), |
| ShortField("len", 16), |
| MACField("dl_addr", "0"), |
| XBitField("pad", 0, 48) ] |
| |
| class OFPATSetNwSrc(_ofp_action_header): |
| name = "OFPAT_SET_NW_SRC" |
| fields_desc = [ ShortEnumField("type", 6, ofp_action_types), |
| ShortField("len", 8), |
| IPField("nw_addr", "0") ] |
| |
| class OFPATSetNwDst(_ofp_action_header): |
| name = "OFPAT_SET_NW_DST" |
| fields_desc = [ ShortEnumField("type", 7, ofp_action_types), |
| ShortField("len", 8), |
| IPField("nw_addr", "0") ] |
| |
| class OFPATSetNwToS(_ofp_action_header): |
| name = "OFPAT_SET_TP_TOS" |
| fields_desc = [ ShortEnumField("type", 8, ofp_action_types), |
| ShortField("len", 8), |
| ByteField("nw_tos", 0), |
| X3BytesField("pad", 0) ] |
| |
| class OFPATSetTpSrc(_ofp_action_header): |
| name = "OFPAT_SET_TP_SRC" |
| fields_desc = [ ShortEnumField("type", 9, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("tp_port", 0), |
| XShortField("pad", 0) ] |
| |
| class OFPATSetTpDst(_ofp_action_header): |
| name = "OFPAT_SET_TP_DST" |
| fields_desc = [ ShortEnumField("type", 10, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("tp_port", 0), |
| XShortField("pad", 0) ] |
| |
| class OFPATEnqueue(_ofp_action_header): |
| name = "OFPAT_ENQUEUE" |
| fields_desc = [ ShortEnumField("type", 11, ofp_action_types), |
| ShortField("len", 16), |
| ShortEnumField("port", 0, ofp_port_no), |
| XBitField("pad", 0, 48), |
| IntField("queue_id", 0) ] |
| |
| class OFPATVendor(_ofp_action_header): |
| name = "OFPAT_VENDOR" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_action_types), |
| ShortField("len", 8), |
| IntField("vendor", 0) ] |
| |
| ofp_action_cls = { 0: OFPATOutput, |
| 1: OFPATSetVLANVID, |
| 2: OFPATSetVLANPCP, |
| 3: OFPATStripVLAN, |
| 4: OFPATSetDlSrc, |
| 5: OFPATSetDlDst, |
| 6: OFPATSetNwSrc, |
| 7: OFPATSetNwDst, |
| 8: OFPATSetNwToS, |
| 9: OFPATSetTpSrc, |
| 10: OFPATSetTpDst, |
| 11: OFPATEnqueue, |
| 65535: OFPATVendor } |
| |
| class ActionPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_action_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_action_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = ActionPacketListField._get_action_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ####################### Queues ###################### |
| |
| class _ofp_queue_property_header(Packet): |
| name = "Dummy OpenFlow Queue Property Header" |
| |
| def post_build(self, p, pay): |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| return p + pay |
| |
| ofp_queue_property_types = { 0: "OFPQT_NONE", |
| 1: "OFPQT_MIN_RATE" } |
| |
| class OFPQTNone(_ofp_queue_property_header): |
| name = "OFPQT_NONE" |
| fields_desc = [ ShortEnumField("type", 0, ofp_queue_property_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPQTMinRate(_ofp_queue_property_header): |
| name = "OFPQT_MIN_RATE" |
| fields_desc = [ ShortEnumField("type", 1, ofp_queue_property_types), |
| ShortField("len", 16), |
| XIntField("pad", 0), |
| ShortField("rate", 0), |
| XBitField("pad2", 0, 48) ] |
| |
| ofp_queue_property_cls = { 0: OFPQTNone, |
| 1: OFPQTMinRate } |
| |
| class QueuePropertyPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_queue_property_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_queue_property_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| l = 0 |
| ret = "" |
| remain = s |
| |
| while remain: |
| l = QueuePropertyPacketListField._get_queue_property_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain + ret, lst |
| |
| class OFPPacketQueue(Packet): |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| def post_build(self, p, pay): |
| if self.properties == []: |
| p += str(OFPQTNone()) |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = p[:4] + struct.pack("!H", l) + p[6:] |
| return p + pay |
| |
| name = "OFP_PACKET_QUEUE" |
| fields_desc = [ IntField("queue_id", 0), |
| ShortField("len", None), |
| XShortField("pad", 0), |
| QueuePropertyPacketListField("properties", [], Packet, |
| length_from=lambda pkt:pkt.len-8) ] |
| |
| class QueuePacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_queue_length(s): |
| return struct.unpack("!H", s[4:6])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| l = 0 |
| ret = "" |
| remain = s |
| |
| while remain: |
| l = QueuePacketListField._get_queue_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPPacketQueue(current) |
| lst.append(p) |
| |
| return remain + ret, lst |
| |
| |
| ##################################################### |
| ############## OpenFlow 1.0 Messages ################ |
| ##################################################### |
| |
| class _ofp_header(Packet): |
| name = "Dummy OpenFlow Header" |
| |
| def post_build(self, p, pay): |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| return p + pay |
| |
| ofp_version = { 0x01: "OpenFlow 1.0", |
| 0x02: "OpenFlow 1.1", |
| 0x03: "OpenFlow 1.2", |
| 0x04: "OpenFlow 1.3", |
| 0x05: "OpenFlow 1.4" } |
| |
| ofp_type = { 0: "OFPT_HELLO", |
| 1: "OFPT_ERROR", |
| 2: "OFPT_ECHO_REQUEST", |
| 3: "OFPT_ECHO_REPLY", |
| 4: "OFPT_VENDOR", |
| 5: "OFPT_FEATURES_REQUEST", |
| 6: "OFPT_FEATURES_REPLY", |
| 7: "OFPT_GET_CONFIG_REQUEST", |
| 8: "OFPT_GET_CONFIG_REPLY", |
| 9: "OFPT_SET_CONFIG", |
| 10: "OFPT_PACKET_IN", |
| 11: "OFPT_FLOW_REMOVED", |
| 12: "OFPT_PORT_STATUS", |
| 13: "OFPT_PACKET_OUT", |
| 14: "OFPT_FLOW_MOD", |
| 15: "OFPT_PORT_MOD", |
| 16: "OFPT_STATS_REQUEST", |
| 17: "OFPT_STATS_REPLY", |
| 18: "OFPT_BARRIER_REQUEST", |
| 19: "OFPT_BARRIER_REPLY", |
| 20: "OFPT_QUEUE_GET_CONFIG_REQUEST", |
| 21: "OFPT_QUEUE_GET_CONFIG_REPLY" } |
| |
| class OFPTHello(_ofp_header): |
| name = "OFPT_HELLO" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 0, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ##################################################### |
| #################### OFPT_ERROR ##################### |
| ##################################################### |
| |
| ### this class will be used to display some messages |
| ### sent back by the switch after an error |
| class OFPacketField(PacketField): |
| def getfield(self, pkt, s): |
| try: |
| l = s[2:4] |
| l = struct.unpack("!H", l)[0] |
| ofload = s[:l] |
| remain = s[l:] |
| return remain, OpenFlow(None, ofload)(ofload) |
| except: |
| return "", Raw(s) |
| |
| ofp_error_type = { 0: "OFPET_HELLO_FAILED", |
| 1: "OFPET_BAD_REQUEST", |
| 2: "OFPET_BAD_ACTION", |
| 3: "OFPET_FLOW_MOD_FAILED", |
| 4: "OFPET_PORT_MOD_FAILED", |
| 5: "OFPET_QUEUE_OP_FAILED" } |
| |
| class OFPETHelloFailed(_ofp_header): |
| name = "OFPET_HELLO_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 0, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPHFC_INCOMPATIBLE", |
| 1: "OFPHFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETBadRequest(_ofp_header): |
| name = "OFPET_BAD_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 1, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPBRC_BAD_VERSION", |
| 1: "OFPBRC_BAD_TYPE", |
| 2: "OFPBRC_BAD_STAT", |
| 3: "OFPBRC_BAD_VENDOR", |
| 4: "OFPBRC_BAD_SUBTYPE", |
| 5: "OFPBRC_EPERM", |
| 6: "OFPBRC_BAD_LEN", |
| 7: "OFPBRC_BUFFER_EMPTY", |
| 8: "OFPBRC_BUFFER_UNKNOWN" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETBadAction(_ofp_header): |
| name = "OFPET_BAD_ACTION" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 2, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPBAC_BAD_TYPE", |
| 1: "OFPBAC_BAD_LEN", |
| 2: "OFPBAC_BAD_VENDOR", |
| 3: "OFPBAC_BAD_VENDOR_TYPE", |
| 4: "OFPBAC_BAD_OUT_PORT", |
| 5: "OFPBAC_BAD_ARGUMENT", |
| 6: "OFPBAC_EPERM", |
| 7: "OFPBAC_TOO_MANY", |
| 8: "OFPBAC_BAD_QUEUE" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETFlowModFailed(_ofp_header): |
| name = "OFPET_FLOW_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 3, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPFMFC_ALL_TABLES_FULL", |
| 1: "OFPFMFC_OVERLAP", |
| 2: "OFPFMFC_EPERM", |
| 3: "OFPFMFC_BAD_EMERG_TIMEOUT", |
| 4: "OFPFMFC_BAD_COMMAND", |
| 5: "OFPFMFC_UNSUPPORTED" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETPortModFailed(_ofp_header): |
| name = "OFPET_PORT_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 4, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPPMFC_BAD_PORT", |
| 1: "OFPPMFC_BAD_HW_ADDR" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETQueueOpFailed(_ofp_header): |
| name = "OFPET_QUEUE_OP_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 5, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPQOFC_BAD_PORT", |
| 1: "OFPQOFC_BAD_QUEUE", |
| 2: "OFPQOFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| # ofp_error_cls allows generic method OpenFlow() to choose the right class for dissection |
| ofp_error_cls = { 0: OFPETHelloFailed, |
| 1: OFPETBadRequest, |
| 2: OFPETBadAction, |
| 3: OFPETFlowModFailed, |
| 4: OFPETPortModFailed, |
| 5: OFPETQueueOpFailed } |
| |
| ################ end of OFPT_ERRORS ################# |
| |
| class OFPTEchoRequest(_ofp_header): |
| name = "OFPT_ECHO_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 2, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTEchoReply(_ofp_header): |
| name = "OFPT_ECHO_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 3, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTVendor(_ofp_header): |
| name = "OFPT_VENDOR" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 4, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntField("vendor", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTFeaturesRequest(_ofp_header): |
| name = "OFPT_FEATURES_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 5, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ofp_action_types_flags = list(ofp_action_types.values())[:-1] # no ofpat_vendor flag |
| |
| class OFPTFeaturesReply(_ofp_header): |
| name = "OFPT_FEATURES_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 6, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| LongField("datapath_id", 0), |
| IntField("n_buffers", 0), |
| ByteField("n_tables", 1), |
| X3BytesField("pad", 0), |
| FlagsField("capabilities", 0, 32, [ "FLOW_STATS", |
| "TABLE_STATS", |
| "PORT_STATS", |
| "STP", |
| "RESERVED", |
| "IP_REASM", |
| "QUEUE_STATS", |
| "ARP_MATCH_IP" ]), |
| FlagsField("actions", 0, 32, ofp_action_types_flags), |
| PacketListField("ports", None, OFPPhyPort, |
| length_from=lambda pkt:pkt.len-32) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTGetConfigRequest(_ofp_header): |
| name = "OFPT_GET_CONFIG_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 7, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTGetConfigReply(_ofp_header): |
| name = "OFPT_GET_CONFIG_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 8, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("flags", 0, { 0: "FRAG_NORMAL", |
| 1: "FRAG_DROP", |
| 2: "FRAG_REASM", |
| 3: "FRAG_MASK" }), |
| ShortField("miss_send_len", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTSetConfig(_ofp_header): |
| name = "OFPT_SET_CONFIG" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 9, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("flags", 0, { 0: "FRAG_NORMAL", |
| 1: "FRAG_DROP", |
| 2: "FRAG_REASM", |
| 3: "FRAG_MASK" }), |
| ShortField("miss_send_len", 128) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTPacketIn(_ofp_header): |
| name = "OFPT_PACKET_IN" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 10, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("buffer_id", "NO_BUFFER", ofp_buffer), |
| ShortField("total_len", 0), |
| ShortEnumField("in_port", 0, ofp_port_no), |
| ByteEnumField("reason", 0, { 0: "OFPR_NO_MATCH", |
| 1: "OFPR_ACTION" }), |
| XByteField("pad", 0), |
| PacketField("data", None, Ether) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTFlowRemoved(_ofp_header): |
| name = "OFPT_FLOW_REMOVED" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 11, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| PacketField("match", OFPMatch(), OFPMatch), |
| LongField("cookie", 0), |
| ShortField("priority", 0), |
| ByteEnumField("reason", 0, { 0: "OFPRR_IDLE_TIMEOUT", |
| 1: "OFPRR_HARD_TIMEOUT", |
| 2: "OFPRR_DELETE" }), |
| XByteField("pad1", 0), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| ShortField("idle_timeout", 0), |
| XShortField("pad2", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTPortStatus(_ofp_header): |
| name = "OFPT_PORT_STATUS" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 12, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ByteEnumField("reason", 0, { 0: "OFPPR_ADD", |
| 1: "OFPPR_DELETE", |
| 2: "OFPPR_MODIFY" }), |
| XBitField("pad", 0, 56), |
| PacketField("desc", OFPPhyPort(), OFPPhyPort) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTPacketOut(_ofp_header): |
| name = "OFPT_PACKET_OUT" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 13, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("buffer_id", "NO_BUFFER", ofp_buffer), |
| ShortEnumField("in_port", "NONE", ofp_port_no), |
| FieldLenField("actions_len", None, fmt="H", length_of="actions"), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.actions_len), |
| PacketField("data", None, Ether) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTFlowMod(_ofp_header): |
| name = "OFPT_FLOW_MOD" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 14, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| PacketField("match", OFPMatch(), OFPMatch), |
| LongField("cookie", 0), |
| ShortEnumField("cmd", 0, { 0: "OFPFC_ADD", |
| 1: "OFPFC_MODIFY", |
| 2: "OFPFC_MODIFY_STRICT", |
| 3: "OFPFC_DELETE", |
| 4: "OFPFC_DELETE_STRICT" }), |
| ShortField("idle_timeout", 0), |
| ShortField("hard_timeout", 0), |
| ShortField("priority", 0), |
| IntEnumField("buffer_id", "NO_BUFFER", ofp_buffer), |
| ShortEnumField("out_port", "NONE", ofp_port_no), |
| FlagsField("flags", 0, 16, [ "SEND_FLOW_REM", |
| "CHECK_OVERLAP", |
| "EMERG" ]), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.len-72) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTPortMod(_ofp_header): |
| name = "OFPT_PORT_MOD" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 15, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("port_no", 0, ofp_port_no), |
| MACField("hw_addr", "0"), |
| FlagsField("config", 0, 32, ofp_port_config), |
| FlagsField("mask", 0, 32, ofp_port_config), |
| FlagsField("advertise", 0, 32, ofp_port_features), |
| IntField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ##################################################### |
| ##################### OFPT_STATS #################### |
| ##################################################### |
| |
| ofp_stats_types = { 0: "OFPST_DESC", |
| 1: "OFPST_FLOW", |
| 2: "OFPST_AGGREGATE", |
| 3: "OFPST_TABLE", |
| 4: "OFPST_PORT", |
| 5: "OFPST_QUEUE", |
| 65535: "OFPST_VENDOR" } |
| |
| class OFPTStatsRequestDesc(_ofp_header): |
| name = "OFPST_STATS_REQUEST_DESC" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 0, ofp_stats_types), |
| FlagsField("flags", 0, 16, []) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTStatsReplyDesc(_ofp_header): |
| name = "OFPST_STATS_REPLY_DESC" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 0, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| StrFixedLenField("mfr_desc", "", 256), |
| StrFixedLenField("hw_desc", "", 256), |
| StrFixedLenField("sw_desc", "", 256), |
| StrFixedLenField("serial_num", "", 32), |
| StrFixedLenField("dp_desc", "", 256) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestFlow(_ofp_header): |
| name = "OFPST_STATS_REQUEST_FLOW" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 1, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| PacketField("match", OFPMatch(), OFPMatch), |
| ByteEnumField("table_id", "ALL", ofp_table), |
| ByteField("pad", 0), |
| ShortEnumField("out_port", "NONE", ofp_port_no) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPFlowStats(Packet): |
| |
| def post_build(self, p, pay): |
| if self.length is None: |
| l = len(p)+len(pay) |
| p = struct.pack("!H", l) + p[2:] |
| return p + pay |
| |
| name = "OFP_FLOW_STATS" |
| fields_desc = [ ShortField("length", None), |
| ByteField("table_id", 0), |
| XByteField("pad1", 0), |
| PacketField("match", OFPMatch(), OFPMatch), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| ShortField("priority", 0), |
| ShortField("idle_timeout", 0), |
| ShortField("hard_timeout", 0), |
| XBitField("pad2", 0, 48), |
| LongField("cookie", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.length-88) ] |
| |
| class FlowStatsPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_flow_stats_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = FlowStatsPacketListField._get_flow_stats_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPFlowStats(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| class OFPTStatsReplyFlow(_ofp_header): |
| name = "OFPST_STATS_REPLY_FLOW" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 1, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| FlowStatsPacketListField("flow_stats", [], Packet, |
| length_from=lambda pkt:pkt.len-12) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestAggregate(_ofp_header): |
| name = "OFPST_STATS_REQUEST_AGGREGATE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 2, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| PacketField("match", OFPMatch(), OFPMatch), |
| ByteEnumField("table_id", "ALL", ofp_table), |
| ByteField("pad", 0), |
| ShortEnumField("out_port", "NONE", ofp_port_no) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTStatsReplyAggregate(_ofp_header): |
| name = "OFPST_STATS_REPLY_AGGREGATE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 2, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| IntField("flow_count", 0), |
| XIntField("pad", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestTable(_ofp_header): |
| name = "OFPST_STATS_REQUEST_TABLE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 3, ofp_stats_types), |
| FlagsField("flags", 0, 16, []) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTableStats(Packet): |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| name = "OFP_TABLE_STATS" |
| fields_desc = [ ByteField("table_id", 0), |
| X3BytesField("pad", 0), |
| StrFixedLenField("name", "", 32), |
| FlagsField("wildcards1", 0x003, 12, [ "DL_VLAN_PCP", |
| "NW_TOS" ]), |
| BitField("nw_dst_mask", 63, 6), # 32 would be enough |
| BitField("nw_src_mask", 63, 6), |
| FlagsField("wildcards2", 0xff, 8, [ "IN_PORT", |
| "DL_VLAN", |
| "DL_SRC", |
| "DL_DST", |
| "DL_TYPE", |
| "NW_PROTO", |
| "TP_SRC", |
| "TP_DST" ]), |
| IntField("max_entries", 0), |
| IntField("active_count", 0), |
| LongField("lookup_count", 0), |
| LongField("matched_count", 0) ] |
| |
| class OFPTStatsReplyTable(_ofp_header): |
| name = "OFPST_STATS_REPLY_TABLE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 3, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| PacketListField("table_stats", None, OFPTableStats, |
| length_from=lambda pkt:pkt.len-12) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestPort(_ofp_header): |
| name = "OFPST_STATS_REQUEST_PORT" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 4, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| ShortEnumField("port_no", "NONE", ofp_port_no), |
| XBitField("pad", 0, 48) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPPortStats(Packet): |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| name = "OFP_PORT_STATS" |
| fields_desc = [ ShortEnumField("port_no", 0, ofp_port_no), |
| XBitField("pad", 0, 48), |
| LongField("rx_packets", 0), |
| LongField("tx_packets", 0), |
| LongField("rx_bytes", 0), |
| LongField("tx_bytes", 0), |
| LongField("rx_dropped", 0), |
| LongField("tx_dropped", 0), |
| LongField("rx_errors", 0), |
| LongField("tx_errors", 0), |
| LongField("rx_frame_err", 0), |
| LongField("rx_over_err", 0), |
| LongField("rx_crc_err", 0), |
| LongField("collisions", 0) ] |
| |
| class OFPTStatsReplyPort(_ofp_header): |
| name = "OFPST_STATS_REPLY_TABLE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 4, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| PacketListField("port_stats", None, OFPPortStats, |
| length_from=lambda pkt:pkt.len-12) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestQueue(_ofp_header): |
| name = "OFPST_STATS_REQUEST_QUEUE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 5, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| ShortEnumField("port_no", "NONE", ofp_port_no), |
| XShortField("pad", 0), |
| IntEnumField("queue_id", "ALL", ofp_queue) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTStatsReplyQueue(_ofp_header): |
| name = "OFPST_STATS_REPLY_QUEUE" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 5, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| ShortEnumField("port_no", "NONE", ofp_port_no), |
| XShortField("pad", 0), |
| IntEnumField("queue_id", "ALL", ofp_queue), |
| LongField("tx_bytes", 0), |
| LongField("tx_packets", 0), |
| LongField("tx_errors", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTStatsRequestVendor(_ofp_header): |
| name = "OFPST_STATS_REQUEST_VENDOR" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 6, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| IntField("vendor", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTStatsReplyVendor(_ofp_header): |
| name = "OFPST_STATS_REPLY_VENDOR" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("stats_type", 6, ofp_stats_types), |
| FlagsField("flags", 0, 16, []), |
| IntField("vendor", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| # ofp_stats_request/reply_cls allows generic method OpenFlow() (end of script) |
| # to choose the right class for dissection |
| ofp_stats_request_cls = { 0: OFPTStatsRequestDesc, |
| 1: OFPTStatsRequestFlow, |
| 2: OFPTStatsRequestAggregate, |
| 3: OFPTStatsRequestTable, |
| 4: OFPTStatsRequestPort, |
| 5: OFPTStatsRequestQueue, |
| 65535: OFPTStatsRequestVendor } |
| |
| ofp_stats_reply_cls = { 0: OFPTStatsReplyDesc, |
| 1: OFPTStatsReplyFlow, |
| 2: OFPTStatsReplyAggregate, |
| 3: OFPTStatsReplyTable, |
| 4: OFPTStatsReplyPort, |
| 5: OFPTStatsReplyQueue, |
| 65535: OFPTStatsReplyVendor } |
| |
| ################ end of OFPT_STATS ################## |
| |
| class OFPTBarrierRequest(_ofp_header): |
| name = "OFPT_BARRIER_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTBarrierReply(_ofp_header): |
| name = "OFPT_BARRIER_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTQueueGetConfigRequest(_ofp_header): |
| name = "OFPT_QUEUE_GET_CONFIG_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 20, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("port", 0, ofp_port_no), |
| XShortField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTQueueGetConfigReply(_ofp_header): |
| name = "OFPT_QUEUE_GET_CONFIG_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x01, ofp_version), |
| ByteEnumField("type", 21, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("port", 0, ofp_port_no), |
| XBitField("pad", 0, 48), |
| QueuePacketListField("queues", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| # ofpt_cls allows generic method OpenFlow() to choose the right class for dissection |
| ofpt_cls = { 0: OFPTHello, |
| #1: OFPTError, |
| 2: OFPTEchoRequest, |
| 3: OFPTEchoReply, |
| 4: OFPTVendor, |
| 5: OFPTFeaturesRequest, |
| 6: OFPTFeaturesReply, |
| 7: OFPTGetConfigRequest, |
| 8: OFPTGetConfigReply, |
| 9: OFPTSetConfig, |
| 10: OFPTPacketIn, |
| 11: OFPTFlowRemoved, |
| 12: OFPTPortStatus, |
| 13: OFPTPacketOut, |
| 14: OFPTFlowMod, |
| 15: OFPTPortMod, |
| #16: OFPTStatsRequest, |
| #17: OFPTStatsReply, |
| 18: OFPTBarrierRequest, |
| 19: OFPTBarrierReply, |
| 20: OFPTQueueGetConfigRequest, |
| 21: OFPTQueueGetConfigReply } |
| |
| TCP_guess_payload_class_copy = TCP.guess_payload_class |
| |
| def OpenFlow(self, payload): |
| if self is None or self.dport == 6653 or self.dport == 6633 or self.sport == 6653 or self.sport == 6633: |
| # port 6653 has been allocated by IANA, port 6633 should no longer be used |
| # OpenFlow function may be called with None self in OFPPacketField |
| of_type = orb(payload[1]) |
| if of_type == 1: |
| err_type = orb(payload[9]) |
| # err_type is a short int, but last byte is enough |
| if err_type == 255: err_type = 65535 |
| return ofp_error_cls[err_type] |
| elif of_type == 16: |
| mp_type = orb(payload[9]) |
| if mp_type == 255: mp_type = 65535 |
| return ofp_stats_request_cls[mp_type] |
| elif of_type == 17: |
| mp_type = orb(payload[9]) |
| if mp_type == 255: mp_type = 65535 |
| return ofp_stats_reply_cls[mp_type] |
| else: |
| return ofpt_cls[of_type] |
| else: |
| return TCP_guess_payload_class_copy(self, payload) |
| |
| TCP.guess_payload_class = OpenFlow |
