@@ -16,11 +16,11 @@ import struct
 from scapy.fields import *
 from scapy.layers.l2 import *
 from scapy.layers.inet import *
-from scapy.compat import orb
+from scapy.compat import orb, raw
 
 ### If prereq_autocomplete is True then match prerequisites will be
 ### automatically handled. See OFPMatch class.
-prereq_autocomplete = False
+conf.contribs['OPENFLOW'] = {'prereq_autocomplete': True}
 
 #####################################################
 ################# Predefined values #################
## 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

Why did you change the default behavior?