| ## 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.3.4 |
| ## Specifications can be retrieved from https://www.opennetworking.org/ |
| |
| # scapy.contrib.description = Openflow v1.3 |
| # 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 * |
| |
| ### If prereq_autocomplete is True then match prerequisites will be |
| ### automatically handled. See OFPMatch class. |
| prereq_autocomplete = False |
| |
| ##################################################### |
| ################# Predefined values ################# |
| ##################################################### |
| |
| ofp_port_no = { 0xfffffff8: "IN_PORT", |
| 0xfffffff9: "TABLE", |
| 0xfffffffa: "NORMAL", |
| 0xfffffffb: "FLOOD", |
| 0xfffffffc: "ALL", |
| 0xfffffffd: "CONTROLLER", |
| 0xfffffffe: "LOCAL", |
| 0xffffffff: "ANY" } |
| |
| ofp_group = { 0xffffff00: "MAX", |
| 0xfffffffc: "ALL", |
| 0xffffffff: "ANY" } |
| |
| ofp_table = { 0xfe: "MAX", |
| 0xff: "ALL" } |
| |
| ofp_queue = { 0xffffffff: "ALL" } |
| |
| ofp_meter = { 0xffff0000: "MAX", |
| 0xfffffffd: "SLOWPATH", |
| 0xfffffffe: "CONTROLLER", |
| 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/OXMs, actions, |
| ### instructions, buckets, queues, meter bands. |
| |
| |
| ################## Hello elements ################### |
| |
| class _ofp_hello_elem_header(Packet): |
| name = "Dummy OpenFlow Hello Elem 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_hello_elem_types = { 1: "OFPHET_VERSIONBITMAP" } |
| |
| class OFPHETVersionBitmap(_ofp_hello_elem_header): |
| name = "OFPHET_VERSIONBITMAP" |
| fields_desc = [ ShortEnumField("type", 1, ofp_hello_elem_types), |
| ShortField("len", 8), |
| FlagsField("bitmap", 0, 32, [ "Type 0", |
| "OFv1.0", |
| "OFv1.1", |
| "OFv1.2", |
| "OFv1.3", |
| "OFv1.4" ]) ] |
| |
| ofp_hello_elem_cls = { 1: OFPHETVersionBitmap } |
| |
| class HelloElemPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_hello_elem_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_hello_elem_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = HelloElemPacketListField._get_hello_elem_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ####################### Ports ####################### |
| |
| ofp_port_config = [ "PORT_DOWN", |
| "NO_STP", # undefined in v1.3 |
| "NO_RECV", |
| "NO_RECV_STP", # undefined in v1.3 |
| "NO_FLOOD", # undefined in v1.3 |
| "NO_FWD", |
| "NO_PACKET_IN" ] |
| |
| ofp_port_state = [ "LINK_DOWN", |
| "BLOCKED", |
| "LIVE" ] |
| |
| ofp_port_features = [ "10MB_HD", |
| "10MB_FD", |
| "100MB_HD", |
| "100MB_FD", |
| "1GB_HD", |
| "1GB_FD", |
| "10GB_FD", |
| "40GB_FD", |
| "100GB_FD", |
| "1TB_FD", |
| "OTHER", |
| "COPPER", |
| "FIBER", |
| "AUTONEG", |
| "PAUSE", |
| "PAUSE_ASYM" ] |
| |
| class OFPPort(Packet): |
| name = "OFP_PHY_PORT" |
| fields_desc = [ IntEnumField("port_no", 0, ofp_port_no), |
| XIntField("pad1", 0), |
| MACField("hw_addr", "0"), |
| XShortField("pad2", 0), |
| StrFixedLenField("port_name", "", 16), |
| FlagsField("config", 0, 32, ofp_port_config), |
| FlagsField("state", 0, 32, 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), |
| IntField("curr_speed", 0), |
| IntField("max_speed", 0) ] |
| |
| def extract_padding(self, s): |
| return "", s |
| # extract_padding is overridden in order for s not to be considered |
| # as belonging to the same layer (s usually contains other OFPPorts) |
| |
| |
| ################### Matches & OXMs ################## |
| |
| ofp_oxm_classes = { 0: "OFPXMC_NXM_0", |
| 1: "OFPXMC_NXM_1", |
| 0x8000: "OFPXMC_OPENFLOW_BASIC", |
| 0xffff: "OFPXMC_EXPERIMENTER" } |
| |
| ofp_oxm_names = { 0: "OFB_IN_PORT", |
| 1: "OFB_IN_PHY_PORT", |
| 2: "OFB_METADATA", |
| 3: "OFB_ETH_DST", |
| 4: "OFB_ETH_SRC", |
| 5: "OFB_ETH_TYPE", |
| 6: "OFB_VLAN_VID", |
| 7: "OFB_VLAN_PCP", |
| 8: "OFB_IP_DSCP", |
| 9: "OFB_IP_ECN", |
| 10: "OFB_IP_PROTO", |
| 11: "OFB_IPV4_SRC", |
| 12: "OFB_IPV4_DST", |
| 13: "OFB_TCP_SRC", |
| 14: "OFB_TCP_DST", |
| 15: "OFB_UDP_SRC", |
| 16: "OFB_UDP_DST", |
| 17: "OFB_SCTP_SRC", |
| 18: "OFB_SCTP_DST", |
| 19: "OFB_ICMPV4_TYPE", |
| 20: "OFB_ICMPV4_CODE", |
| 21: "OFB_ARP_OP", |
| 22: "OFB_ARP_SPA", |
| 23: "OFB_ARP_TPA", |
| 24: "OFB_ARP_SHA", |
| 25: "OFB_ARP_THA", |
| 26: "OFB_IPV6_SRC", |
| 27: "OFB_IPV6_DST", |
| 28: "OFB_IPV6_FLABEL", |
| 29: "OFB_ICMPV6_TYPE", |
| 30: "OFB_ICMPV6_CODE", |
| 31: "OFB_IPV6_ND_TARGET", |
| 32: "OFB_IPV6_ND_SLL", |
| 33: "OFB_IPV6_ND_TLL", |
| 34: "OFB_MPLS_LABEL", |
| 35: "OFB_MPLS_TC", |
| 36: "OFB_MPLS_BOS", |
| 37: "OFB_PBB_ISID", |
| 38: "OFB_TUNNEL_ID", |
| 39: "OFB_IPV6_EXTHDR" } |
| |
| ofp_oxm_constr = { 0: ["OFBInPort", "in_port", 4], |
| 1: ["OFBInPhyPort", "in_phy_port", 4], |
| 2: ["OFBMetadata", "metadata", 8], |
| 3: ["OFBEthDst", "eth_dst", 6], |
| 4: ["OFBEthSrc", "eth_src", 6], |
| 5: ["OFBEthType", "eth_type", 2], |
| 6: ["OFBVLANVID", "vlan_vid", 2], |
| 7: ["OFBVLANPCP", "vlan_pcp", 1], |
| 8: ["OFBIPDSCP", "ip_dscp", 1], |
| 9: ["OFBIPECN", "ip_ecn", 1], |
| 10: ["OFBIPProto", "ip_proto", 1], |
| 11: ["OFBIPv4Src", "ipv4_src", 4], |
| 12: ["OFBIPv4Dst", "ipv4_dst", 4], |
| 13: ["OFBTCPSrc", "tcp_src", 2], |
| 14: ["OFBTCPDst", "tcp_dst", 2], |
| 15: ["OFBUDPSrc", "udp_src", 2], |
| 16: ["OFBUDPDst", "udp_dst", 2], |
| 17: ["OFBSCTPSrc", "sctp_src", 2], |
| 18: ["OFBSCTPDst", "sctp_dst", 2], |
| 19: ["OFBICMPv4Type", "icmpv4_type", 1], |
| 20: ["OFBICMPv4Code", "icmpv4_code", 1], |
| 21: ["OFBARPOP", "arp_op", 2], |
| 22: ["OFBARPSPA", "arp_spa", 4], |
| 23: ["OFBARPTPA", "arp_tpa", 4], |
| 24: ["OFBARPSHA", "arp_sha", 6], |
| 25: ["OFBARPTHA", "arp_tha", 6], |
| 26: ["OFBIPv6Src", "ipv6_src", 16], |
| 27: ["OFBIPv6Dst", "ipv6_dst", 16], |
| 28: ["OFBIPv6FLabel", "ipv6_flabel", 4], |
| 29: ["OFBICMPv6Type", "icmpv6_type", 1], |
| 30: ["OFBICMPv6Code", "icmpv6_code", 1], |
| 31: ["OFBIPv6NDTarget", "ipv6_nd_target", 16], |
| 32: ["OFBIPv6NDSLL", "ipv6_sll", 6], |
| 33: ["OFBIPv6NDTLL", "ipv6_tll", 6], |
| 34: ["OFBMPLSLabel", "mpls_label", 4], |
| 35: ["OFBMPLSTC", "mpls_tc", 1], |
| 36: ["OFBMPLSBoS", "mpls_bos", 1], |
| 37: ["OFBPBBISID", "pbb_isid", 3], |
| 38: ["OFBTunnelID", "tunnel_id", 8], |
| 39: ["OFBIPv6ExtHdr", "ipv6_ext_hdr_flags", 2] } |
| |
| # the ipv6flags array is useful only to the OFBIPv6ExtHdr class |
| ipv6flags = [ "NONEXT", |
| "ESP", |
| "AUTH", |
| "DEST", |
| "FRAG", |
| "ROUTER", |
| "HOP", |
| "UNREP", |
| "UNSEQ" ] |
| |
| ### here we fill ofp_oxm_fields with the fields that will be used |
| ### to generate the various OXM classes |
| ### e.g. the call to add_ofp_oxm_fields(0, ["OFBInPort", "in_port", 4]) |
| ### will add {0: [ShortEnumField("class",..), BitEnumField("field",..),..]} |
| ofp_oxm_fields = {} |
| def add_ofp_oxm_fields(i, org): |
| ofp_oxm_fields[i] = [ ShortEnumField("class", "OFPXMC_OPENFLOW_BASIC", ofp_oxm_classes), |
| BitEnumField("field", i//2, 7, ofp_oxm_names), |
| BitField("hasmask", i%2, 1) ] |
| ofp_oxm_fields[i].append(ByteField("length", org[2]+org[2]*(i%2))) |
| if i//2 == 0: # OFBInPort |
| ofp_oxm_fields[i].append(IntEnumField(org[1], 0, ofp_port_no)) |
| elif i//2 == 3 or i//2 == 4: # OFBEthSrc & OFBEthDst |
| ofp_oxm_fields[i].append(MACField(org[1], None)) |
| elif i//2 == 11 or i//2 == 12: # OFBIPv4Src & OFBIPv4Dst |
| ofp_oxm_fields[i].append(IPField(org[1], "0")) |
| elif i//2 == 39: # OFBIPv6ExtHdr |
| ofp_oxm_fields[i].append(FlagsField(org[1], 0, 8*org[2], ipv6flags)) |
| else: |
| ofp_oxm_fields[i].append(BitField(org[1], 0, 8*org[2])) |
| if i%2: |
| ofp_oxm_fields[i].append(BitField(org[1]+"_mask", 0, 8*org[2])) |
| |
| # some HM classes are not supported par OFv1.3 but we will create them anyway |
| for i,cls in ofp_oxm_constr.items(): |
| add_ofp_oxm_fields(2*i, cls) |
| add_ofp_oxm_fields(2*i+1, cls) |
| |
| ### now we create every OXM class with the same call, |
| ### (except that static variable create_oxm_class.i is each time different) |
| ### and we fill ofp_oxm_cls with them |
| ofp_oxm_cls = {} |
| ofp_oxm_id_cls = {} |
| def create_oxm_cls(): |
| # static variable initialization |
| if not hasattr(create_oxm_cls, "i"): |
| create_oxm_cls.i = 0 |
| |
| index = create_oxm_cls.i |
| cls_name = ofp_oxm_constr[index//4][0] |
| # we create standard OXM then OXM ID then OXM with mask then OXM-hasmask ID |
| if index % 4 == 2: |
| cls_name += "HM" |
| if index % 2: |
| cls_name += "ID" |
| |
| oxm_name = ofp_oxm_names[index//4] |
| oxm_fields = ofp_oxm_fields[index//2] |
| # for ID classes we just want the first 4 fields (no payload) |
| if index % 2: |
| oxm_fields = oxm_fields[:4] |
| |
| cls = type(cls_name, (Packet,), { "name": oxm_name, "fields_desc": oxm_fields }) |
| ### the first call to special function type will create the same class as in |
| ### class OFBInPort(Packet): |
| ### def __init__(self): |
| ### self.name = "OFB_IN_PORT" |
| ### self.fields_desc = [ ShortEnumField("class", 0x8000, ofp_oxm_classes), |
| ### BitEnumField("field", 0, 7, ofp_oxm_names), |
| ### BitField("hasmask", 0, 1), |
| ### ByteField("length", 4), |
| ### IntEnumField("in_port", 0, ofp_port_no) ] |
| |
| if index % 2 == 0: |
| ofp_oxm_cls[index//2] = cls |
| else: |
| ofp_oxm_id_cls[index//2] = cls |
| create_oxm_cls.i += 1 |
| return cls |
| |
| OFBInPort = create_oxm_cls() |
| OFBInPortID = create_oxm_cls() |
| OFBInPortHM = create_oxm_cls() |
| OFBInPortHMID = create_oxm_cls() |
| OFBInPhyPort = create_oxm_cls() |
| OFBInPhyPortID = create_oxm_cls() |
| OFBInPhyPortHM = create_oxm_cls() |
| OFBInPhyPortHMID = create_oxm_cls() |
| OFBMetadata = create_oxm_cls() |
| OFBMetadataID = create_oxm_cls() |
| OFBMetadataHM = create_oxm_cls() |
| OFBMetadataHMID = create_oxm_cls() |
| OFBEthDst = create_oxm_cls() |
| OFBEthDstID = create_oxm_cls() |
| OFBEthDstHM = create_oxm_cls() |
| OFBEthDstHMID = create_oxm_cls() |
| OFBEthSrc = create_oxm_cls() |
| OFBEthSrcID = create_oxm_cls() |
| OFBEthSrcHM = create_oxm_cls() |
| OFBEthSrcHMID = create_oxm_cls() |
| OFBEthType = create_oxm_cls() |
| OFBEthTypeID = create_oxm_cls() |
| OFBEthTypeHM = create_oxm_cls() |
| OFBEthTypeHMID = create_oxm_cls() |
| OFBVLANVID = create_oxm_cls() |
| OFBVLANVIDID = create_oxm_cls() |
| OFBVLANVIDHM = create_oxm_cls() |
| OFBVLANVIDHMID = create_oxm_cls() |
| OFBVLANPCP = create_oxm_cls() |
| OFBVLANPCPID = create_oxm_cls() |
| OFBVLANPCPHM = create_oxm_cls() |
| OFBVLANPCPHMID = create_oxm_cls() |
| OFBIPDSCP = create_oxm_cls() |
| OFBIPDSCPID = create_oxm_cls() |
| OFBIPDSCPHM = create_oxm_cls() |
| OFBIPDSCPHMID = create_oxm_cls() |
| OFBIPECN = create_oxm_cls() |
| OFBIPECNID = create_oxm_cls() |
| OFBIPECNHM = create_oxm_cls() |
| OFBIPECNHMID = create_oxm_cls() |
| OFBIPProto = create_oxm_cls() |
| OFBIPProtoID = create_oxm_cls() |
| OFBIPProtoHM = create_oxm_cls() |
| OFBIPProtoHMID = create_oxm_cls() |
| OFBIPv4Src = create_oxm_cls() |
| OFBIPv4SrcID = create_oxm_cls() |
| OFBIPv4SrcHM = create_oxm_cls() |
| OFBIPv4SrcHMID = create_oxm_cls() |
| OFBIPv4Dst = create_oxm_cls() |
| OFBIPv4DstID = create_oxm_cls() |
| OFBIPv4DstHM = create_oxm_cls() |
| OFBIPv4DstHMID = create_oxm_cls() |
| OFBTCPSrc = create_oxm_cls() |
| OFBTCPSrcID = create_oxm_cls() |
| OFBTCPSrcHM = create_oxm_cls() |
| OFBTCPSrcHMID = create_oxm_cls() |
| OFBTCPDst = create_oxm_cls() |
| OFBTCPDstID = create_oxm_cls() |
| OFBTCPDstHM = create_oxm_cls() |
| OFBTCPDstHMID = create_oxm_cls() |
| OFBUDPSrc = create_oxm_cls() |
| OFBUDPSrcID = create_oxm_cls() |
| OFBUDPSrcHM = create_oxm_cls() |
| OFBUDPSrcHMID = create_oxm_cls() |
| OFBUDPDst = create_oxm_cls() |
| OFBUDPDstID = create_oxm_cls() |
| OFBUDPDstHM = create_oxm_cls() |
| OFBUDPDstHMID = create_oxm_cls() |
| OFBSCTPSrc = create_oxm_cls() |
| OFBSCTPSrcID = create_oxm_cls() |
| OFBSCTPSrcHM = create_oxm_cls() |
| OFBSCTPSrcHMID = create_oxm_cls() |
| OFBSCTPDst = create_oxm_cls() |
| OFBSCTPDstID = create_oxm_cls() |
| OFBSCTPDstHM = create_oxm_cls() |
| OFBSCTPDstHMID = create_oxm_cls() |
| OFBICMPv4Type = create_oxm_cls() |
| OFBICMPv4TypeID = create_oxm_cls() |
| OFBICMPv4TypeHM = create_oxm_cls() |
| OFBICMPv4TypeHMID = create_oxm_cls() |
| OFBICMPv4Code = create_oxm_cls() |
| OFBICMPv4CodeID = create_oxm_cls() |
| OFBICMPv4CodeHM = create_oxm_cls() |
| OFBICMPv4CodeHMID = create_oxm_cls() |
| OFBARPOP = create_oxm_cls() |
| OFBARPOPID = create_oxm_cls() |
| OFBARPOPHM = create_oxm_cls() |
| OFBARPOPHMID = create_oxm_cls() |
| OFBARPSPA = create_oxm_cls() |
| OFBARPSPAID = create_oxm_cls() |
| OFBARPSPAHM = create_oxm_cls() |
| OFBARPSPAHMID = create_oxm_cls() |
| OFBARPTPA = create_oxm_cls() |
| OFBARPTPAID = create_oxm_cls() |
| OFBARPTPAHM = create_oxm_cls() |
| OFBARPTPAHMID = create_oxm_cls() |
| OFBARPSHA = create_oxm_cls() |
| OFBARPSHAID = create_oxm_cls() |
| OFBARPSHAHM = create_oxm_cls() |
| OFBARPSHAHMID = create_oxm_cls() |
| OFBARPTHA = create_oxm_cls() |
| OFBARPTHAID = create_oxm_cls() |
| OFBARPTHAHM = create_oxm_cls() |
| OFBARPTHAHMID = create_oxm_cls() |
| OFBIPv6Src = create_oxm_cls() |
| OFBIPv6SrcID = create_oxm_cls() |
| OFBIPv6SrcHM = create_oxm_cls() |
| OFBIPv6SrcHMID = create_oxm_cls() |
| OFBIPv6Dst = create_oxm_cls() |
| OFBIPv6DstID = create_oxm_cls() |
| OFBIPv6DstHM = create_oxm_cls() |
| OFBIPv6DstHMID = create_oxm_cls() |
| OFBIPv6FLabel = create_oxm_cls() |
| OFBIPv6FLabelID = create_oxm_cls() |
| OFBIPv6FLabelHM = create_oxm_cls() |
| OFBIPv6FLabelHMID = create_oxm_cls() |
| OFBICMPv6Type = create_oxm_cls() |
| OFBICMPv6TypeID = create_oxm_cls() |
| OFBICMPv6TypeHM = create_oxm_cls() |
| OFBICMPv6TypeHMID = create_oxm_cls() |
| OFBICMPv6Code = create_oxm_cls() |
| OFBICMPv6CodeID = create_oxm_cls() |
| OFBICMPv6CodeHM = create_oxm_cls() |
| OFBICMPv6CodeHMID = create_oxm_cls() |
| OFBIPv6NDTarget = create_oxm_cls() |
| OFBIPv6NDTargetID = create_oxm_cls() |
| OFBIPv6NDTargetHM = create_oxm_cls() |
| OFBIPv6NDTargetHMID = create_oxm_cls() |
| OFBIPv6NDSLL = create_oxm_cls() |
| OFBIPv6NDSLLID = create_oxm_cls() |
| OFBIPv6NDSLLHM = create_oxm_cls() |
| OFBIPv6NDSLLHMID = create_oxm_cls() |
| OFBIPv6NDTLL = create_oxm_cls() |
| OFBIPv6NDTLLID = create_oxm_cls() |
| OFBIPv6NDTLLHM = create_oxm_cls() |
| OFBIPv6NDTLLHMID = create_oxm_cls() |
| OFBMPLSLabel = create_oxm_cls() |
| OFBMPLSLabelID = create_oxm_cls() |
| OFBMPLSLabelHM = create_oxm_cls() |
| OFBMPLSLabelHMID = create_oxm_cls() |
| OFBMPLSTC = create_oxm_cls() |
| OFBMPLSTCID = create_oxm_cls() |
| OFBMPLSTCHM = create_oxm_cls() |
| OFBMPLSTCHMID = create_oxm_cls() |
| OFBMPLSBoS = create_oxm_cls() |
| OFBMPLSBoSID = create_oxm_cls() |
| OFBMPLSBoSHM = create_oxm_cls() |
| OFBMPLSBoSHMID = create_oxm_cls() |
| OFBPBBISID = create_oxm_cls() |
| OFBPBBISIDID = create_oxm_cls() |
| OFBPBBISIDHM = create_oxm_cls() |
| OFBPBBISIDHMID = create_oxm_cls() |
| OFBTunnelID = create_oxm_cls() |
| OFBTunnelIDID = create_oxm_cls() |
| OFBTunnelIDHM = create_oxm_cls() |
| OFBTunnelIDHMID = create_oxm_cls() |
| OFBIPv6ExtHdr = create_oxm_cls() |
| OFBIPv6ExtHdrID = create_oxm_cls() |
| OFBIPv6ExtHdrHM = create_oxm_cls() |
| OFBIPv6ExtHdrHMID = create_oxm_cls() |
| |
| ### need_prereq holds a list of prerequisites defined in 7.2.3.8 of the specifications |
| ### e.g. if you want to use an OFBTCPSrc instance (code 26) |
| ### you first need to declare an OFBIPProto instance (code 20) with value 6, |
| ### and if you want to use an OFBIPProto instance (still code 20) |
| ### you first need to declare an OFBEthType instance (code 10) with value 0x0800 |
| ### (0x0800 means IPv4 by default, but you might want to use 0x86dd with IPv6) |
| ### need_prereq codes are two times higher than previous oxm classes codes, |
| ### except for 21 which is sort of a proxy for IPv6 (see below) |
| need_prereq = { 14: [12, 0x1000], |
| 16: [10, 0x0800], # could be 0x86dd |
| 18: [10, 0x0800], # could be 0x86dd |
| 20: [10, 0x0800], # could be 0x86dd |
| 21: [10, 0x86dd], |
| 22: [10, 0x0800], |
| 24: [10, 0x0800], |
| 26: [20, 6], |
| 28: [20, 6], |
| 30: [20, 17], |
| 32: [20, 17], |
| 34: [20, 132], |
| 36: [20, 132], |
| 38: [20, 1], |
| 40: [20, 1], |
| 42: [10, 0x0806], |
| 44: [10, 0x0806], |
| 46: [10, 0x0806], |
| 48: [10, 0x0806], |
| 50: [10, 0x0806], |
| 52: [10, 0x86dd], |
| 54: [10, 0x86dd], |
| 56: [10, 0x86dd], |
| 58: [21, 58], ### small trick here, we refer to normally non- |
| 60: [21, 58], ### existent field 21 to distinguish ipv6 |
| 62: [58, 135], # could be 136 |
| 64: [58, 135], |
| 66: [58, 136], |
| 68: [10, 0x8847], # could be 0x8848 |
| 70: [10, 0x8847], # could be 0x8848 |
| 72: [10, 0x8847], # could be 0x8848 |
| 74: [10, 0x88e7], |
| 78: [10, 0x86dd] } |
| |
| class OXMPacketListField(PacketListField): |
| |
| __slots__ = ["autocomplete", "index"] |
| |
| def __init__(self, name, default, cls, length_from=None, autocomplete=prereq_autocomplete): |
| PacketListField.__init__(self, name, default, cls, length_from=length_from) |
| self.autocomplete = autocomplete |
| self.index = [] |
| |
| def i2m(self, pkt, val): |
| ### this part makes for a faster writing of specs-compliant matches |
| ### expect some unwanted behaviour if you try incoherent associations |
| ### you might want to set autocomplete=False in __init__ method |
| if self.autocomplete: |
| # val might be modified during the loop so we need a fixed copy |
| fix_val = copy.deepcopy(val) |
| for oxm in fix_val: |
| f = 2*oxm.field |
| fix_index = list(self.index) |
| while f in need_prereq: |
| # this loop enables a small recursion |
| # e.g. ipv6_nd<--icmpv6<--ip_proto<--eth_type |
| prereq = need_prereq[f] |
| f = prereq[0] |
| f2 = 20 if f == 21 else f # ipv6 trick... |
| if f2 not in fix_index: |
| self.index.insert(0, f2) |
| prrq = ofp_oxm_cls[f2]() # never HM |
| setattr(prrq, ofp_oxm_constr[f2//2][1], prereq[1]) |
| val.insert(0, prrq) |
| # we could do more complicated stuff to |
| # make sure prerequisite order is correct |
| # but it works well when presented with any coherent input |
| # e.g. you should not mix OFBTCPSrc with OFBICMPv6Code |
| # and expect to get coherent results... |
| # you can still go manual by setting prereq_autocomplete=False |
| return val |
| |
| def m2i(self, pkt, s): |
| t = orb(s[2]) |
| nrm_t = t - t%2 |
| if nrm_t not in self.index: |
| self.index.append(nrm_t) |
| return ofp_oxm_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_oxm_length(s): |
| return orb(s[3]) |
| |
| def addfield(self, pkt, s, val): |
| return s + b"".join(raw(x) for x in self.i2m(pkt, val)) |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| lim = self.length_from(pkt) |
| ret = s[lim:] |
| remain = s[:lim] |
| |
| while remain and len(remain) > 4: |
| l = OXMPacketListField._get_oxm_length(remain) + 4 |
| # this could also be done by parsing oxm_fields (fixed lengths) |
| if l <= 4 or len(remain) < l: |
| # no incoherent length |
| break |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| self.index = [] |
| ### since OXMPacketListField is called only twice (when OFPMatch and OFPSetField |
| ### classes are created) and not when you want to instantiate an OFPMatch, |
| ### index needs to be reinitialized, otherwise there will be some conflicts |
| ### e.g. if you create OFPMatch with OFBTCPSrc and then change to OFBTCPDst, |
| ### index will already be filled with ethertype and nwproto codes, |
| ### thus the corresponding fields will not be added to the packet |
| return remain + ret, lst |
| |
| class OXMIDPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = orb(s[2]) |
| return ofp_oxm_id_cls.get(t, Raw)(s) |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| lim = self.length_from(pkt) |
| ret = s[lim:] |
| remain = s[:lim] |
| |
| while remain and len(remain) >= 4: |
| # all OXM ID are 32-bit long (no experimenter OXM support here) |
| current = remain[:4] |
| remain = remain[4:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain + ret, lst |
| |
| |
| class OFPMatch(Packet): |
| def post_build(self, p, pay): |
| l = self.length |
| if l is None: |
| l = len(p)+len(pay) |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| zero_bytes = (8 - l%8) % 8 |
| p += b"\x00" * zero_bytes |
| # message with user-defined length will not be automatically padded |
| return p + pay |
| |
| def extract_padding(self, s): |
| l = self.length |
| zero_bytes = (8 - l%8) % 8 |
| return s[zero_bytes:], s[:zero_bytes] |
| |
| name = "OFP_MATCH" |
| fields_desc= [ ShortEnumField("type", 1, { 0: "OFPMT_STANDARD", |
| 1: "OFPMT_OXM" }), |
| ShortField("length", None), |
| OXMPacketListField("oxm_fields", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| ### ofp_match is no longer a fixed-length structure in v1.3 |
| ### furthermore it may include variable padding |
| ### we introduce to that end a subclass of PacketField |
| class MatchField(PacketField): |
| def __init__(self, name): |
| PacketField.__init__(self, name, OFPMatch(), OFPMatch) |
| |
| def getfield(self, pkt, s): |
| i = self.m2i(pkt, s) |
| ### i can be <OFPMatch> or <OFPMatch <Padding>> |
| ### or <OFPMatch <Raw>> or <OFPMatch <Raw <Padding>>> |
| ### and we want to return "", <OFPMatch> or "", <OFPMatch <Padding>> |
| ### or raw(<Raw>), <OFPMatch> or raw(<Raw>), <OFPMatch <Padding>> |
| if Raw in i: |
| r = i[Raw] |
| if Padding in r: |
| p = r[Padding] |
| i.payload = p |
| del(r.payload) |
| return r.load, i |
| else: |
| return b"", i |
| |
| |
| ###################### 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", |
| 11: "OFPAT_COPY_TTL_OUT", |
| 12: "OFPAT_COPY_TTL_IN", |
| 13: "OFPAT_SET_MPLS_LABEL", |
| 14: "OFPAT_DEC_MPLS_TC", |
| 15: "OFPAT_SET_MPLS_TTL", |
| 16: "OFPAT_DEC_MPLS_TTL", |
| 17: "OFPAT_PUSH_VLAN", |
| 18: "OFPAT_POP_VLAN", |
| 19: "OFPAT_PUSH_MPLS", |
| 20: "OFPAT_POP_MPLS", |
| 21: "OFPAT_SET_QUEUE", |
| 22: "OFPAT_GROUP", |
| 23: "OFPAT_SET_NW_TTL", |
| 24: "OFPAT_DEC_NW_TTL", |
| 25: "OFPAT_SET_FIELD", |
| 26: "OFPAT_PUSH_PBB", |
| 27: "OFPAT_POP_PBB", |
| 65535: "OFPAT_EXPERIMENTER" } |
| |
| class OFPATOutput(_ofp_action_header): |
| name = "OFPAT_OUTPUT" |
| fields_desc = [ ShortEnumField("type", 0, ofp_action_types), |
| ShortField("len", 16), |
| IntEnumField("port", 0, ofp_port_no), |
| ShortEnumField("max_len", "NO_BUFFER", ofp_max_len), |
| XBitField("pad", 0, 48) ] |
| |
| # the following actions are not supported by OFv1.3 |
| |
| 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), |
| # ShortField("port", 0), |
| # XBitField("pad", 0, 48), |
| # IntEnumField("queue_id", 0, ofp_queue) ] |
| |
| class OFPATSetMPLSLabel(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_LABEL" |
| fields_desc = [ ShortEnumField("type", 13, ofp_action_types), |
| ShortField("len", 8), |
| IntField("mpls_label", 0) ] |
| |
| class OFPATSetMPLSTC(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_TC" |
| fields_desc = [ ShortEnumField("type", 14, ofp_action_types), |
| ShortField("len", 8), |
| ByteField("mpls_tc", 0), |
| X3BytesField("pad", 0) ] |
| |
| # end of unsupported actions |
| |
| class OFPATCopyTTLOut(_ofp_action_header): |
| name = "OFPAT_COPY_TTL_OUT" |
| fields_desc = [ ShortEnumField("type", 11, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATCopyTTLIn(_ofp_action_header): |
| name = "OFPAT_COPY_TTL_IN" |
| fields_desc = [ ShortEnumField("type", 12, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATSetMPLSTTL(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_TTL" |
| fields_desc = [ ShortEnumField("type", 15, ofp_action_types), |
| ShortField("len", 8), |
| ByteField("mpls_ttl", 0), |
| X3BytesField("pad", 0) ] |
| |
| class OFPATDecMPLSTTL(_ofp_action_header): |
| name = "OFPAT_DEC_MPLS_TTL" |
| fields_desc = [ ShortEnumField("type", 16, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATPushVLAN(_ofp_action_header): |
| name = "OFPAT_PUSH_VLAN" |
| fields_desc = [ ShortEnumField("type", 17, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("ethertype", 0x8100), # or 0x88a8 |
| XShortField("pad", 0) ] |
| |
| class OFPATPopVLAN(_ofp_action_header): |
| name = "OFPAT_POP_VLAN" |
| fields_desc = [ ShortEnumField("type", 18, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATPushMPLS(_ofp_action_header): |
| name = "OFPAT_PUSH_MPLS" |
| fields_desc = [ ShortEnumField("type", 19, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("ethertype", 0x8847), # or 0x8848 |
| XShortField("pad", 0) ] |
| |
| class OFPATPopMPLS(_ofp_action_header): |
| name = "OFPAT_POP_MPLS" |
| fields_desc = [ ShortEnumField("type", 20, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("ethertype", 0x8847), # or 0x8848 |
| XShortField("pad", 0) ] |
| |
| class OFPATSetQueue(_ofp_action_header): |
| name = "OFPAT_SET_QUEUE" |
| fields_desc = [ ShortEnumField("type", 21, ofp_action_types), |
| ShortField("len", 8), |
| IntEnumField("queue_id", 0, ofp_queue) ] |
| |
| class OFPATGroup(_ofp_action_header): |
| name = "OFPAT_GROUP" |
| fields_desc = [ ShortEnumField("type", 22, ofp_action_types), |
| ShortField("len", 8), |
| IntEnumField("group_id", 0, ofp_group) ] |
| |
| class OFPATSetNwTTL(_ofp_action_header): |
| name = "OFPAT_SET_NW_TTL" |
| fields_desc = [ ShortEnumField("type", 23, ofp_action_types), |
| ShortField("len", 8), |
| ByteField("nw_ttl", 0), |
| X3BytesField("pad", 0) ] |
| |
| class OFPATDecNwTTL(_ofp_action_header): |
| name = "OFPAT_DEC_NW_TTL" |
| fields_desc = [ ShortEnumField("type", 24, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATSetField(_ofp_action_header): |
| |
| def post_build(self, p, pay): |
| l = self.len |
| zero_bytes = 0 |
| if l is None: |
| l = len(p)+len(pay) |
| zero_bytes = (8 - l%8) % 8 |
| l = l + zero_bytes # add padding length |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| else: |
| zero_bytes = (8 - l%8) % 8 |
| # every message will be padded correctly |
| p += b"\x00" * zero_bytes |
| return p + pay |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| name = "OFPAT_SET_FIELD" |
| fields_desc = [ ShortEnumField("type", 25, ofp_action_types), |
| ShortField("len", None), |
| # there should not be more than one oxm tlv |
| OXMPacketListField("field", [], Packet, |
| length_from=lambda pkt:pkt.len-4, |
| # /!\ contains padding! |
| autocomplete=False) ] |
| |
| class OFPATPushPBB(_ofp_action_header): |
| name = "OFPAT_PUSH_PBB" |
| fields_desc = [ ShortEnumField("type", 26, ofp_action_types), |
| ShortField("len", 8), |
| ShortField("ethertype", 0x88e7), |
| XShortField("pad", 0) ] |
| |
| class OFPATPopPBB(_ofp_action_header): |
| name = "OFPAT_POP_PBB" |
| fields_desc = [ ShortEnumField("type", 27, ofp_action_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPATExperimenter(_ofp_action_header): |
| name = "OFPAT_EXPERIMENTER" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_action_types), |
| ShortField("len", 8), |
| IntField("experimenter", 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, |
| 11: OFPATCopyTTLOut, |
| 12: OFPATCopyTTLIn, |
| 13: OFPATSetMPLSLabel, |
| 14: OFPATSetMPLSTC, |
| 15: OFPATSetMPLSTTL, |
| 16: OFPATDecMPLSTTL, |
| 17: OFPATPushVLAN, |
| 18: OFPATPopVLAN, |
| 19: OFPATPushMPLS, |
| 20: OFPATPopMPLS, |
| 21: OFPATSetQueue, |
| 22: OFPATGroup, |
| 23: OFPATSetNwTTL, |
| 24: OFPATDecNwTTL, |
| 25: OFPATSetField, |
| 26: OFPATPushPBB, |
| 27: OFPATPopPBB, |
| 65535: OFPATExperimenter } |
| |
| 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 and len(remain)>=4: |
| l = ActionPacketListField._get_action_length(remain) |
| if l < 8 or len(remain) < l: |
| # length should be at least 8 (non-zero, 64-bit aligned), |
| # and no incoherent length |
| break |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ##################### Action IDs #################### |
| |
| # length is computed as in instruction structures, |
| # so we reuse _ofp_instruction_header |
| |
| class OFPATOutputID(_ofp_action_header): |
| name = "OFPAT_OUTPUT" |
| fields_desc = [ ShortEnumField("type", 0, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| # the following actions are not supported by OFv1.3 |
| |
| class OFPATSetVLANVIDID(_ofp_action_header): |
| name = "OFPAT_SET_VLAN_VID" |
| fields_desc = [ ShortEnumField("type", 1, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetVLANPCPID(_ofp_action_header): |
| name = "OFPAT_SET_VLAN_PCP" |
| fields_desc = [ ShortEnumField("type", 2, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATStripVLANID(_ofp_action_header): |
| name = "OFPAT_STRIP_VLAN" |
| fields_desc = [ ShortEnumField("type", 3, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetDlSrcID(_ofp_action_header): |
| name = "OFPAT_SET_DL_SRC" |
| fields_desc = [ ShortEnumField("type", 4, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetDlDstID(_ofp_action_header): |
| name = "OFPAT_SET_DL_DST" |
| fields_desc = [ ShortEnumField("type", 5, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetNwSrcID(_ofp_action_header): |
| name = "OFPAT_SET_NW_SRC" |
| fields_desc = [ ShortEnumField("type", 6, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetNwDstID(_ofp_action_header): |
| name = "OFPAT_SET_NW_DST" |
| fields_desc = [ ShortEnumField("type", 7, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetNwToSID(_ofp_action_header): |
| name = "OFPAT_SET_TP_TOS" |
| fields_desc = [ ShortEnumField("type", 8, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetTpSrcID(_ofp_action_header): |
| name = "OFPAT_SET_TP_SRC" |
| fields_desc = [ ShortEnumField("type", 9, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetTpDstID(_ofp_action_header): |
| name = "OFPAT_SET_TP_DST" |
| fields_desc = [ ShortEnumField("type", 10, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| #class OFPATEnqueueID(_ofp_action_header): |
| # name = "OFPAT_ENQUEUE" |
| # fields_desc = [ ShortEnumField("type", 11, ofp_action_types), |
| # ShortField("len", 4) ] |
| |
| class OFPATSetMPLSLabelID(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_LABEL" |
| fields_desc = [ ShortEnumField("type", 13, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetMPLSTCID(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_TC" |
| fields_desc = [ ShortEnumField("type", 14, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| # end of unsupported actions |
| |
| class OFPATCopyTTLOutID(_ofp_action_header): |
| name = "OFPAT_COPY_TTL_OUT" |
| fields_desc = [ ShortEnumField("type", 11, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATCopyTTLInID(_ofp_action_header): |
| name = "OFPAT_COPY_TTL_IN" |
| fields_desc = [ ShortEnumField("type", 12, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetMPLSTTLID(_ofp_action_header): |
| name = "OFPAT_SET_MPLS_TTL" |
| fields_desc = [ ShortEnumField("type", 15, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATDecMPLSTTLID(_ofp_action_header): |
| name = "OFPAT_DEC_MPLS_TTL" |
| fields_desc = [ ShortEnumField("type", 16, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPushVLANID(_ofp_action_header): |
| name = "OFPAT_PUSH_VLAN" |
| fields_desc = [ ShortEnumField("type", 17, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPopVLANID(_ofp_action_header): |
| name = "OFPAT_POP_VLAN" |
| fields_desc = [ ShortEnumField("type", 18, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPushMPLSID(_ofp_action_header): |
| name = "OFPAT_PUSH_MPLS" |
| fields_desc = [ ShortEnumField("type", 19, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPopMPLSID(_ofp_action_header): |
| name = "OFPAT_POP_MPLS" |
| fields_desc = [ ShortEnumField("type", 20, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetQueueID(_ofp_action_header): |
| name = "OFPAT_SET_QUEUE" |
| fields_desc = [ ShortEnumField("type", 21, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATGroupID(_ofp_action_header): |
| name = "OFPAT_GROUP" |
| fields_desc = [ ShortEnumField("type", 22, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetNwTTLID(_ofp_action_header): |
| name = "OFPAT_SET_NW_TTL" |
| fields_desc = [ ShortEnumField("type", 23, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATDecNwTTLID(_ofp_action_header): |
| name = "OFPAT_DEC_NW_TTL" |
| fields_desc = [ ShortEnumField("type", 24, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATSetFieldID(_ofp_action_header): |
| name = "OFPAT_SET_FIELD" |
| fields_desc = [ ShortEnumField("type", 25, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPushPBBID(_ofp_action_header): |
| name = "OFPAT_PUSH_PBB" |
| fields_desc = [ ShortEnumField("type", 26, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATPopPBBID(_ofp_action_header): |
| name = "OFPAT_POP_PBB" |
| fields_desc = [ ShortEnumField("type", 27, ofp_action_types), |
| ShortField("len", 4) ] |
| |
| class OFPATExperimenterID(_ofp_action_header): |
| name = "OFPAT_EXPERIMENTER" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_action_types), |
| ShortField("len", None) ] |
| |
| ofp_action_id_cls = { 0: OFPATOutputID, |
| 1: OFPATSetVLANVIDID, |
| 2: OFPATSetVLANPCPID, |
| 3: OFPATStripVLANID, |
| 4: OFPATSetDlSrcID, |
| 5: OFPATSetDlDstID, |
| 6: OFPATSetNwSrcID, |
| 7: OFPATSetNwDstID, |
| 8: OFPATSetNwToSID, |
| 9: OFPATSetTpSrcID, |
| 10: OFPATSetTpDstID, |
| #11: OFPATEnqueueID, |
| 11: OFPATCopyTTLOutID, |
| 12: OFPATCopyTTLInID, |
| 13: OFPATSetMPLSLabelID, |
| 14: OFPATSetMPLSTCID, |
| 15: OFPATSetMPLSTTLID, |
| 16: OFPATDecMPLSTTLID, |
| 17: OFPATPushVLANID, |
| 18: OFPATPopVLANID, |
| 19: OFPATPushMPLSID, |
| 20: OFPATPopMPLSID, |
| 21: OFPATSetQueueID, |
| 22: OFPATGroupID, |
| 23: OFPATSetNwTTLID, |
| 24: OFPATDecNwTTLID, |
| 25: OFPATSetFieldID, |
| 26: OFPATPushPBBID, |
| 27: OFPATPopPBBID, |
| 65535: OFPATExperimenterID } |
| |
| class ActionIDPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_action_id_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_action_id_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain and len(remain) >= 4: |
| l = ActionIDPacketListField._get_action_id_length(remain) |
| if l < 4 or len(remain) < l: |
| # length is 4 (may be more for experimenter messages), |
| # and no incoherent length |
| break |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| #################### Instructions ################### |
| |
| class _ofp_instruction_header(Packet): |
| name = "Dummy OpenFlow Instruction 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_instruction_types = { 1: "OFPIT_GOTO_TABLE", |
| 2: "OFPIT_WRITE_METADATA", |
| 3: "OFPIT_WRITE_ACTIONS", |
| 4: "OFPIT_APPLY_ACTIONS", |
| 5: "OFPIT_CLEAR_ACTIONS", |
| 6: "OFPIT_METER", |
| 65535: "OFPIT_EXPERIMENTER" } |
| |
| class OFPITGotoTable(_ofp_instruction_header): |
| name = "OFPIT_GOTO_TABLE" |
| fields_desc = [ ShortEnumField("type", 1, ofp_instruction_types), |
| ShortField("len", 8), |
| ByteEnumField("table_id", 0, ofp_table), |
| X3BytesField("pad", 0) ] |
| |
| class OFPITWriteMetadata(_ofp_instruction_header): |
| name = "OFPIT_WRITE_METADATA" |
| fields_desc = [ ShortEnumField("type", 2, ofp_instruction_types), |
| ShortField("len", 24), |
| XIntField("pad", 0), |
| LongField("metadata", 0), |
| LongField("metadata_mask", 0) ] |
| |
| class OFPITWriteActions(_ofp_instruction_header): |
| name = "OFPIT_WRITE_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 3, ofp_instruction_types), |
| ShortField("len", None), |
| XIntField("pad", 0), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.len-8) ] |
| |
| class OFPITApplyActions(_ofp_instruction_header): |
| name = "OFPIT_APPLY_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 4, ofp_instruction_types), |
| ShortField("len", None), |
| XIntField("pad", 0), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.len-8) ] |
| |
| class OFPITClearActions(_ofp_instruction_header): |
| name = "OFPIT_CLEAR_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 5, ofp_instruction_types), |
| ShortField("len", 8), |
| XIntField("pad", 0) ] |
| |
| class OFPITMeter(_ofp_instruction_header): |
| name = "OFPIT_METER" |
| fields_desc = [ ShortEnumField("type", 6, ofp_instruction_types), |
| ShortField("len", 8), |
| IntEnumField("meter_id", 1, ofp_meter) ] |
| |
| class OFPITExperimenter(_ofp_instruction_header): |
| name = "OFPIT_EXPERIMENTER" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_instruction_types), |
| ShortField("len", None), |
| IntField("experimenter", 0) ] |
| |
| ofp_instruction_cls = { 1: OFPITGotoTable, |
| 2: OFPITWriteMetadata, |
| 3: OFPITWriteActions, |
| 4: OFPITApplyActions, |
| 5: OFPITClearActions, |
| 6: OFPITMeter, |
| 65535: OFPITExperimenter } |
| |
| class InstructionPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_instruction_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_instruction_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain and len(remain) > 4: |
| l = InstructionPacketListField._get_instruction_length(remain) |
| if l < 8 or len(remain) < l: |
| # length should be at least 8 (non-zero, 64-bit aligned), |
| # and no incoherent length |
| break |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ################## Instruction IDs ################## |
| |
| # length is computed as in instruction structures, |
| # so we reuse _ofp_instruction_header |
| |
| class OFPITGotoTableID(_ofp_instruction_header): |
| name = "OFPIT_GOTO_TABLE" |
| fields_desc = [ ShortEnumField("type", 1, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITWriteMetadataID(_ofp_instruction_header): |
| name = "OFPIT_WRITE_METADATA" |
| fields_desc = [ ShortEnumField("type", 2, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITWriteActionsID(_ofp_instruction_header): |
| name = "OFPIT_WRITE_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 3, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITApplyActionsID(_ofp_instruction_header): |
| name = "OFPIT_APPLY_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 4, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITClearActionsID(_ofp_instruction_header): |
| name = "OFPIT_CLEAR_ACTIONS" |
| fields_desc = [ ShortEnumField("type", 5, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITMeterID(_ofp_instruction_header): |
| name = "OFPIT_METER" |
| fields_desc = [ ShortEnumField("type", 6, ofp_instruction_types), |
| ShortField("len", 4) ] |
| |
| class OFPITExperimenterID(_ofp_instruction_header): |
| name = "OFPIT_EXPERIMENTER" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_instruction_types), |
| ShortField("len", None) ] |
| |
| ofp_instruction_id_cls = { 1: OFPITGotoTableID, |
| 2: OFPITWriteMetadataID, |
| 3: OFPITWriteActionsID, |
| 4: OFPITApplyActionsID, |
| 5: OFPITClearActionsID, |
| 6: OFPITMeterID, |
| 65535: OFPITExperimenterID } |
| |
| class InstructionIDPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_instruction_cls.get(t, Raw)(s) |
| |
| @staticmethod |
| def _get_instruction_id_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain and len(remain) >= 4: |
| l = InstructionIDPacketListField._get_instruction_id_length(remain) |
| if l < 4 or len(remain) < l: |
| # length is 4 (may be more for experimenter messages), |
| # and no incoherent length |
| break |
| current = remain[:l] |
| remain = remain[l:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ###################### Buckets ###################### |
| |
| class OFPBucket(Packet): |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| def post_build(self, p, pay): |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = struct.pack("!H", l) + p[2:] |
| return p + pay |
| |
| name = "OFP_BUCKET" |
| fields_desc = [ ShortField("len", None), |
| ShortField("weight", 0), |
| IntEnumField("watch_port", 0, ofp_port_no), |
| IntEnumField("watch_group", 0, ofp_group), |
| XIntField("pad", 0), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| |
| class BucketPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_bucket_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = BucketPacketListField._get_bucket_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPBucket(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("pad1", 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 = [] |
| 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, lst |
| |
| class OFPPacketQueue(Packet): |
| |
| def extract_padding(self, s): |
| return "", s |
| |
| def post_build(self, p, pay): |
| if self.properties == []: |
| p += raw(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 = [ IntEnumField("queue_id", 0, ofp_queue), |
| 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 = [] |
| remain = s |
| |
| while remain: |
| l = QueuePacketListField._get_queue_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPPacketQueue(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| #################### Meter bands #################### |
| |
| ofp_meter_band_types = { 0: "OFPMBT_DROP", |
| 1: "OFPMBT_DSCP_REMARK", |
| 65535: "OFPMBT_EXPERIMENTER" } |
| |
| class OFPMBTDrop(Packet): |
| name = "OFPMBT_DROP" |
| fields_desc = [ ShortEnumField("type", 0, ofp_queue_property_types), |
| ShortField("len", 16), |
| IntField("rate", 0), |
| IntField("burst_size", 0), |
| XIntField("pad", 0) ] |
| |
| class OFPMBTDSCPRemark(Packet): |
| name = "OFPMBT_DSCP_REMARK" |
| fields_desc = [ ShortEnumField("type", 1, ofp_queue_property_types), |
| ShortField("len", 16), |
| IntField("rate", 0), |
| IntField("burst_size", 0), |
| ByteField("prec_level", 0), |
| X3BytesField("pad", 0) ] |
| |
| class OFPMBTExperimenter(Packet): |
| name = "OFPMBT_EXPERIMENTER" |
| fields_desc = [ ShortEnumField("type", 65535, ofp_queue_property_types), |
| ShortField("len", 16), |
| IntField("rate", 0), |
| IntField("burst_size", 0), |
| IntField("experimenter", 0) ] |
| |
| ofp_meter_band_cls = { 0: OFPMBTDrop, |
| 1: OFPMBTDSCPRemark, |
| 2: OFPMBTExperimenter } |
| |
| class MeterBandPacketListField(PacketListField): |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_meter_band_cls.get(t, Raw)(s) |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| current = remain[:16] |
| remain = remain[16:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| ##################################################### |
| ############## OpenFlow 1.3 Messages ################ |
| ##################################################### |
| |
| 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_EXPERIMENTER", |
| 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_GROUP_MOD", |
| 16: "OFPT_PORT_MOD", |
| 17: "OFPT_TABLE_MOD", |
| 18: "OFPT_MULTIPART_REQUEST", |
| 19: "OFPT_MULTIPART_REPLY", |
| 20: "OFPT_BARRIER_REQUEST", |
| 21: "OFPT_BARRIER_REPLY", |
| 22: "OFPT_QUEUE_GET_CONFIG_REQUEST", |
| 23: "OFPT_QUEUE_GET_CONFIG_REPLY", |
| 24: "OFPT_ROLE_REQUEST", |
| 25: "OFPT_ROLE_REPLY", |
| 26: "OFPT_GET_ASYNC_REQUEST", |
| 27: "OFPT_GET_ASYNC_REPLY", |
| 28: "OFPT_SET_ASYNC", |
| 29: "OFPT_METER_MOD" } |
| |
| 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 |
| |
| class OFPTHello(_ofp_header): |
| name = "OFPT_HELLO" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 0, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| HelloElemPacketListField("elements", [], Packet, |
| length_from=lambda pkt:pkt.len-32) ] |
| 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 b"", Raw(s) |
| |
| ofp_error_type = { 0: "OFPET_HELLO_FAILED", |
| 1: "OFPET_BAD_REQUEST", |
| 2: "OFPET_BAD_ACTION", |
| 3: "OFPET_BAD_INSTRUCTION", |
| 4: "OFPET_BAD_MATCH", |
| 5: "OFPET_FLOW_MOD_FAILED", |
| 6: "OFPET_GROUP_MOD_FAILED", |
| 7: "OFPET_PORT_MOD_FAILED", |
| 8: "OFPET_TABLE_MOD_FAILED", |
| 9: "OFPET_QUEUE_OP_FAILED", |
| 10: "OFPET_SWITCH_CONFIG_FAILED", |
| 11: "OFPET_ROLE_REQUEST_FAILED", |
| 12: "OFPET_METER_MOD_FAILED", |
| 13: "OFPET_TABLE_FEATURES_FAILED", |
| 65535: "OFPET_EXPERIMENTER" } |
| |
| class OFPETHelloFailed(_ofp_header): |
| name = "OFPET_HELLO_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, 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", 0x04, 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_MULTIPART", |
| 3: "OFPBRC_BAD_EXPERIMENTER", |
| 4: "OFPBRC_BAD_EXP_TYPE", |
| 5: "OFPBRC_EPERM", |
| 6: "OFPBRC_BAD_LEN", |
| 7: "OFPBRC_BUFFER_EMPTY", |
| 8: "OFPBRC_BUFFER_UNKNOWN", |
| 9: "OFPBRC_BAD_TABLE_ID", |
| 10: "OFPBRC_IS_SLAVE", |
| 11: "OFPBRC_BAD_PORT", |
| 12: "OFPBRC_BAD_PACKET", |
| 13: "OFPBRC_MULTIPART_BUFFER_OVERFLOW" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETBadAction(_ofp_header): |
| name = "OFPET_BAD_ACTION" |
| fields_desc = [ ByteEnumField("version", 0x04, 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_EXPERIMENTER", |
| 3: "OFPBAC_BAD_EXP_TYPE", |
| 4: "OFPBAC_BAD_OUT_PORT", |
| 5: "OFPBAC_BAD_ARGUMENT", |
| 6: "OFPBAC_EPERM", |
| 7: "OFPBAC_TOO_MANY", |
| 8: "OFPBAC_BAD_QUEUE", |
| 9: "OFPBAC_BAD_OUT_GROUP", |
| 10: "OFPBAC_MATCH_INCONSISTENT", |
| 11: "OFPBAC_UNSUPPORTED_ORDER", |
| 12: "OFPBAC_BAD_TAG", |
| 13: "OFPBAC_BAD_SET_TYPE", |
| 14: "OFPBAC_BAD_SET_LEN", |
| 15: "OFPBAC_BAD_SET_ARGUMENT" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETBadInstruction(_ofp_header): |
| name = "OFPET_BAD_INSTRUCTION" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 3, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPBIC_UNKNOWN_INST", |
| 1: "OFPBIC_UNSUP_INST", |
| 2: "OFPBIC_BAD_TABLE_ID", |
| 3: "OFPBIC_UNSUP_METADATA", |
| 4: "OFPBIC_UNSUP_METADATA_MASK", |
| 5: "OFPBIC_BAD_EXPERIMENTER", |
| 6: "OFPBIC_BAD_EXP_TYPE", |
| 7: "OFPBIC_BAD_LEN", |
| 8: "OFPBIC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETBadMatch(_ofp_header): |
| name = "OFPET_BAD_MATCH" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 4, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPBMC_BAD_TYPE", |
| 1: "OFPBMC_BAD_LEN", |
| 2: "OFPBMC_BAD_TAG", |
| 3: "OFPBMC_BAD_DL_ADDR_MASK", |
| 4: "OFPBMC_BAD_NW_ADDR_MASK", |
| 5: "OFPBMC_BAD_WILDCARDS", |
| 6: "OFPBMC_BAD_FIELD", |
| 7: "OFPBMC_BAD_VALUE", |
| 8: "OFPBMC_BAD_MASK", |
| 9: "OFPBMC_BAD_PREREQ", |
| 10: "OFPBMC_DUP_FIELD", |
| 11: "OFPBMC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETFlowModFailed(_ofp_header): |
| name = "OFPET_FLOW_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 5, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPFMFC_UNKNOWN", |
| 1: "OFPFMFC_TABLE_FULL", |
| 2: "OFPFMFC_BAD_TABLE_ID", |
| 3: "OFPFMFC_OVERLAP", |
| 4: "OFPFMFC_EPERM", |
| 5: "OFPFMFC_BAD_TIMEOUT", |
| 6: "OFPFMFC_BAD_COMMAND", |
| 7: "OFPFMFC_BAD_FLAGS" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETGroupModFailed(_ofp_header): |
| name = "OFPET_GROUP_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 6, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPGMFC_GROUP_EXISTS", |
| 1: "OFPGMFC_INVALID_GROUP", |
| 2: "OFPGMFC_WEIGHT_UNSUPPORTED", |
| 3: "OFPGMFC_OUT_OF_GROUPS", |
| 4: "OFPGMFC_OUT_OF_BUCKETS", |
| 5: "OFPGMFC_CHAINING_UNSUPPORTED", |
| 6: "OFPGMFC_WATCH_UNSUPPORTED", |
| 7: "OFPGMFC_LOOP", |
| 8: "OFPGMFC_UNKNOWN_GROUP", |
| 9: "OFPGMFC_CHAINED_GROUP", |
| 10: "OFPGMFC_BAD_TYPE", |
| 11: "OFPGMFC_BAD_COMMAND", |
| 12: "OFPGMFC_BAD_BUCKET", |
| 13: "OFPGMFC_BAD_WATCH", |
| 14: "OFPFMFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETPortModFailed(_ofp_header): |
| name = "OFPET_PORT_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 7, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPPMFC_BAD_PORT", |
| 1: "OFPPMFC_BAD_HW_ADDR", |
| 2: "OFPPMFC_BAD_CONFIG", |
| 3: "OFPPMFC_BAD_ADVERTISE", |
| 4: "OFPPMFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETTableModFailed(_ofp_header): |
| name = "OFPET_TABLE_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 8, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPTMFC_BAD_TABLE", |
| 1: "OFPTMFC_BAD_CONFIG", |
| 2: "OFPTMFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETQueueOpFailed(_ofp_header): |
| name = "OFPET_QUEUE_OP_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 9, 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}} |
| |
| class OFPETSwitchConfigFailed(_ofp_header): |
| name = "OFPET_SWITCH_CONFIG_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 10, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPSCFC_BAD_FLAGS", |
| 1: "OFPSCFC_BAD_LEN", |
| 2: "OFPSCFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETRoleRequestFailed(_ofp_header): |
| name = "OFPET_ROLE_REQUEST_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 11, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPRRFC_STALE", |
| 1: "OFPRRFC_UNSUP", |
| 2: "OFPRRFC_BAD_ROLE" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETMeterModFailed(_ofp_header): |
| name = "OFPET_METER_MOD_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 12, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPMMFC_UNKNOWN", |
| 1: "OFPMMFC_METER_EXISTS", |
| 2: "OFPMMFC_INVALID_METER", |
| 3: "OFPMMFC_UNKNOWN_METER", |
| 4: "OFPMMFC_BAD_COMMAND", |
| 5: "OFPMMFC_BAD_FLAGS", |
| 6: "OFPMMFC_BAD_RATE", |
| 7: "OFPMMFC_BAD_BURST", |
| 8: "OFPMMFC_BAD_BAND", |
| 9: "OFPMMFC_BAD_BAND_VALUE", |
| 10: "OFPMMFC_OUT_OF_METERS", |
| 11: "OFPMMFC_OUT_OF_BANDS" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETTableFeaturesFailed(_ofp_header): |
| name = "OFPET_TABLE_FEATURES_FAILED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", 13, ofp_error_type), |
| ShortEnumField("errcode", 0, { 0: "OFPTFFC_BAD_TABLE", |
| 1: "OFPTFFC_BAD_METADATA", |
| 2: "OFPTFFC_BAD_TYPE", |
| 3: "OFPTFFC_BAD_LEN", |
| 4: "OFPTFFC_BAD_ARGUMENT", |
| 5: "OFPTFFC_EPERM" }), |
| OFPacketField("data", "", Raw) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPETExperimenter(_ofp_header): |
| name = "OFPET_EXPERIMENTER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 1, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("errtype", "OFPET_EXPERIMENTER", ofp_error_type), |
| ShortField("exp_type", None), |
| IntField("experimenter", None), |
| 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: OFPETBadInstruction, |
| 4: OFPETBadMatch, |
| 5: OFPETFlowModFailed, |
| 6: OFPETGroupModFailed, |
| 7: OFPETPortModFailed, |
| 8: OFPETTableModFailed, |
| 9: OFPETQueueOpFailed, |
| 10: OFPETSwitchConfigFailed, |
| 11: OFPETRoleRequestFailed, |
| 12: OFPETMeterModFailed, |
| 13: OFPETTableFeaturesFailed, |
| 65535: OFPETExperimenter } |
| |
| ################ end of OFPT_ERRORS ################# |
| |
| class OFPTEchoRequest(_ofp_header): |
| name = "OFPT_ECHO_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, 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", 0x04, ofp_version), |
| ByteEnumField("type", 3, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTExperimenter(_ofp_header): |
| name = "OFPT_EXPERIMENTER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 4, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntField("experimenter", 0), |
| IntField("exp_type", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTFeaturesRequest(_ofp_header): |
| name = "OFPT_FEATURES_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 5, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTFeaturesReply(_ofp_header): |
| name = "OFPT_FEATURES_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x04, 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), |
| ByteField("auxiliary_id", 0), |
| XShortField("pad", 0), |
| FlagsField("capabilities", 0, 32, [ "FLOW_STATS", |
| "TABLE_STATS", |
| "PORT_STATS", |
| "GROUP_STATS", |
| "RESERVED", #undefined |
| "IP_REASM", |
| "QUEUE_STATS", |
| "ARP_MATCH_IP", #undefined |
| "PORT_BLOCKED"]), |
| IntField("reserved", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTGetConfigRequest(_ofp_header): |
| name = "OFPT_GET_CONFIG_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, 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", 0x04, 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", 0x04, 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", 0x04, ofp_version), |
| ByteEnumField("type", 10, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("buffer_id", "NO_BUFFER", ofp_buffer), |
| ShortField("total_len", 0), |
| ByteEnumField("reason", 0, { 0: "OFPR_NO_MATCH", |
| 1: "OFPR_ACTION", |
| 2: "OFPR_INVALID_TTL"}), |
| ByteEnumField("table_id", 0, ofp_table), |
| LongField("cookie", 0), |
| MatchField("match"), |
| XShortField("pad", 0), |
| PacketField("data", "", Ether) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTFlowRemoved(_ofp_header): |
| name = "OFPT_FLOW_REMOVED" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 11, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| LongField("cookie", 0), |
| ShortField("priority", 0), |
| ByteEnumField("reason", 0, { 0: "OFPRR_IDLE_TIMEOUT", |
| 1: "OFPRR_HARD_TIMEOUT", |
| 2: "OFPRR_DELETE", |
| 3: "OFPRR_GROUP_DELETE"}), |
| ByteEnumField("table_id", 0, ofp_table), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| ShortField("idle_timeout", 0), |
| ShortField("hard_timeout", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| MatchField("match") ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTPortStatus(_ofp_header): |
| name = "OFPT_PORT_STATUS" |
| fields_desc = [ ByteEnumField("version", 0x04, 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", OFPPort(), OFPPort) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTPacketOut(_ofp_header): |
| name = "OFPT_PACKET_OUT" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 13, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("buffer_id", "NO_BUFFER", ofp_buffer), |
| IntEnumField("in_port", "CONTROLLER", ofp_port_no), |
| FieldLenField("actions_len", None, fmt="H", length_of="actions"), |
| XBitField("pad", 0, 48), |
| ActionPacketListField("actions", [], Packet, |
| length_from=lambda pkt:pkt.actions_len), |
| PacketField("data", "", Ether) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTFlowMod(_ofp_header): |
| name = "OFPT_FLOW_MOD" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 14, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| LongField("cookie", 0), |
| LongField("cookie_mask", 0), |
| ByteEnumField("table_id", 0, ofp_table), |
| ByteEnumField("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), |
| IntEnumField("out_port", "ANY", ofp_port_no), |
| IntEnumField("out_group", "ANY", ofp_group), |
| FlagsField("flags", 0, 16, [ "SEND_FLOW_REM", |
| "CHECK_OVERLAP", |
| "RESET_COUNTS", |
| "NO_PKT_COUNTS", |
| "NO_BYT_COUNTS" ]), |
| XShortField("pad", 0), |
| MatchField("match"), |
| InstructionPacketListField("instructions", [], Packet, |
| length_from=lambda pkt:pkt.len-48-(pkt.match.length+(8-pkt.match.length%8)%8)) ] |
| # include match padding to match.length |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTGroupMod(_ofp_header): |
| name = "OFPT_GROUP_MOD" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 15, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("cmd", 0, { 0: "OFPGC_ADD", |
| 1: "OFPGC_MODIFY", |
| 2: "OFPGC_DELETE" }), |
| ByteEnumField("group_type", 0, { 0: "OFPGT_ALL", |
| 1: "OFPGT_SELECT", |
| 2: "OFPGT_INDIRECT", |
| 3: "OFPGT_FF" }), |
| XByteField("pad", 0), |
| IntEnumField("group_id", 0, ofp_group), |
| BucketPacketListField("buckets", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTPortMod(_ofp_header): |
| name = "OFPT_PORT_MOD" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 16, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("port_no", 0, ofp_port_no), |
| XIntField("pad1", 0), |
| MACField("hw_addr", "0"), |
| XShortField("pad2", 0), |
| FlagsField("config", 0, 32, ofp_port_config), |
| FlagsField("mask", 0, 32, ofp_port_config), |
| FlagsField("advertise", 0, 32, ofp_port_features), |
| XIntField("pad3", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTTableMod(_ofp_header): |
| name = "OFPT_TABLE_MOD" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 17, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ByteEnumField("table_id", 0, ofp_table), |
| X3BytesField("pad", 0), |
| IntEnumField("config", 0, { 3: "OFPTC_DEPRECATED_MASK"}) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ##################################################### |
| ################## OFPT_MULTIPART ################### |
| ##################################################### |
| |
| ofp_multipart_types = { 0: "OFPMP_DESC", |
| 1: "OFPMP_FLOW", |
| 2: "OFPMP_AGGREGATE", |
| 3: "OFPMP_TABLE", |
| 4: "OFPMP_PORT_STATS", |
| 5: "OFPMP_QUEUE", |
| 6: "OFPMP_GROUP", |
| 7: "OFPMP_GROUP_DESC", |
| 8: "OFPMP_GROUP_FEATURES", |
| 9: "OFPMP_METER", |
| 10: "OFPMP_METER_CONFIG", |
| 11: "OFPMP_METER_FEATURES", |
| 12: "OFPMP_TABLE_FEATURES", |
| 13: "OFPMP_PORT_DESC", |
| 65535: "OFPST_VENDOR" } |
| |
| ofpmp_request_flags = [ "REQ_MORE" ] |
| |
| ofpmp_reply_flags = [ "REPLY_MORE" ] |
| |
| class OFPMPRequestDesc(_ofp_header): |
| name = "OFPMP_REQUEST_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 0, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyDesc(_ofp_header): |
| name = "OFPMP_REPLY_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 0, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad", 0), |
| 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 OFPMPRequestFlow(_ofp_header): |
| name = "OFPMP_REQUEST_FLOW" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 1, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| ByteEnumField("table_id", "ALL", ofp_table), |
| X3BytesField("pad2", 0), |
| IntEnumField("out_port", "ANY", ofp_port_no), |
| IntEnumField("out_group", "ANY", ofp_group), |
| IntField("pad3", 0), |
| LongField("cookie", 0), |
| LongField("cookie_mask", 0), |
| MatchField("match") ] |
| 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), |
| ByteEnumField("table_id", 0, ofp_table), |
| XByteField("pad1", 0), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| ShortField("priority", 0), |
| ShortField("idle_timeout", 0), |
| ShortField("hard_timeout", 0), |
| FlagsField("flags", 0, 16, [ "SEND_FLOW_REM", |
| "CHECK_OVERLAP", |
| "RESET_COUNTS", |
| "NO_PKT_COUNTS", |
| "NO_BYT_COUNTS" ]), |
| IntField("pad2", 0), |
| LongField("cookie", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| MatchField("match"), |
| InstructionPacketListField("instructions", [], Packet, |
| length_from=lambda pkt:pkt.length-56-pkt.match.length) ] |
| |
| 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 OFPMPReplyFlow(_ofp_header): |
| name = "OFPMP_REPLY_FLOW" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 1, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| FlowStatsPacketListField("flow_stats", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestAggregate(_ofp_header): |
| name = "OFPMP_REQUEST_AGGREGATE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 2, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| ByteEnumField("table_id", "ALL", ofp_table), |
| X3BytesField("pad2", 0), |
| IntEnumField("out_port", "ANY", ofp_port_no), |
| IntEnumField("out_group", "ANY", ofp_group), |
| IntField("pad3", 0), |
| LongField("cookie", 0), |
| LongField("cookie_mask", 0), |
| MatchField("match") ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyAggregate(_ofp_header): |
| name = "OFPMP_REPLY_AGGREGATE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 2, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| IntField("flow_count", 0), |
| XIntField("pad2", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestTable(_ofp_header): |
| name = "OFPMP_REQUEST_TABLE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 3, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTableStats(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_TABLE_STATS" |
| fields_desc = [ ByteEnumField("table_id", 0, ofp_table), |
| X3BytesField("pad1", 0), |
| IntField("active_count", 0), |
| LongField("lookup_count", 0), |
| LongField("matched_count", 0) ] |
| |
| class OFPMPReplyTable(_ofp_header): |
| name = "OFPMP_REPLY_TABLE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 3, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| PacketListField("table_stats", None, OFPTableStats, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestPortStats(_ofp_header): |
| name = "OFPMP_REQUEST_PORT_STATS" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 4, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("port_no", "ANY", ofp_port_no), |
| XIntField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPPortStats(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_PORT_STATS" |
| fields_desc = [ IntEnumField("port_no", 0, ofp_port_no), |
| XIntField("pad", 0), |
| 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), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0) ] |
| |
| class OFPMPReplyPortStats(_ofp_header): |
| name = "OFPMP_REPLY_PORT_STATS" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 4, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| PacketListField("port_stats", None, OFPPortStats, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestQueue(_ofp_header): |
| name = "OFPMP_REQUEST_QUEUE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 5, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("port_no", "ANY", ofp_port_no), |
| IntEnumField("queue_id", "ALL", ofp_queue) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPQueueStats(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_QUEUE_STATS" |
| fields_desc = [ IntEnumField("port_no", 0, ofp_port_no), |
| IntEnumField("queue_id", 0, ofp_queue), |
| LongField("tx_bytes", 0), |
| LongField("tx_packets", 0), |
| LongField("tx_errors", 0), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0) ] |
| |
| class OFPMPReplyQueue(_ofp_header): |
| name = "OFPMP_REPLY_QUEUE" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 5, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| PacketListField("queue_stats", None, OFPQueueStats, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestGroup(_ofp_header): |
| name = "OFPMP_REQUEST_GROUP" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 6, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("group_id", "ANY", ofp_group), |
| XIntField("pad2", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPBucketStats(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_BUCKET_STATS" |
| fields_desc = [ LongField("packet_count", 0), |
| LongField("byte_count", 0) ] |
| |
| class OFPGroupStats(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_GROUP_STATS" |
| fields_desc = [ ShortField("length", None), |
| XShortField("pad1", 0), |
| IntEnumField("group_id", 0, ofp_group), |
| IntField("ref_count", 0), |
| IntField("pad2", 0), |
| LongField("packet_count", 0), |
| LongField("byte_count", 0), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| PacketListField("bucket_stats", None, OFPBucketStats, |
| length_from=lambda pkt:pkt.length-40) ] |
| |
| class GroupStatsPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_group_stats_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = GroupStatsPacketListField._get_group_stats_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPGroupStats(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| class OFPMPReplyGroup(_ofp_header): |
| name = "OFPMP_REPLY_GROUP" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 6, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| GroupStatsPacketListField("group_stats", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestGroupDesc(_ofp_header): |
| name = "OFPMP_REQUEST_GROUP_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 7, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPGroupDesc(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_GROUP_DESC" |
| fields_desc = [ ShortField("length", None), |
| ByteEnumField("type", 0, { 0: "OFPGT_ALL", |
| 1: "OFPGT_SELECT", |
| 2: "OFPGT_INDIRECT", |
| 3: "OFPGT_FF" }), |
| XByteField("pad", 0), |
| IntEnumField("group_id", 0, ofp_group), |
| BucketPacketListField("buckets", None, Packet, |
| length_from=lambda pkt:pkt.length-8) ] |
| |
| class GroupDescPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_group_desc_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = GroupDescPacketListField._get_group_desc_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPGroupDesc(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| |
| class OFPMPReplyGroupDesc(_ofp_header): |
| name = "OFPMP_REPLY_GROUP_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 7, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| GroupDescPacketListField("group_descs", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestGroupFeatures(_ofp_header): |
| name = "OFPMP_REQUEST_GROUP_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 8, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ofp_action_types_flags = list(ofp_action_types.values())[:-1] # no ofpat_experimenter flag |
| class OFPMPReplyGroupFeatures(_ofp_header): |
| name = "OFPMP_REPLY_GROUP_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 8, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| FlagsField("types", 0, 32, [ "ALL", |
| "SELECT", |
| "INDIRECT", |
| "FF" ]), |
| FlagsField("capabilities", 0, 32, [ "SELECT_WEIGHT", |
| "SELECT_LIVENESS", |
| "CHAINING", |
| "CHAINING_CHECKS" ]), |
| IntField("max_group_all", 0), |
| IntField("max_group_select", 0), |
| IntField("max_group_indirect", 0), |
| IntField("max_group_ff", 0), |
| # no ofpat_experimenter flag |
| FlagsField("actions_all", 0, 32, ofp_action_types_flags), |
| FlagsField("actions_select", 0, 32, ofp_action_types_flags), |
| FlagsField("actions_indirect", 0, 32, ofp_action_types_flags), |
| FlagsField("actions_ff", 0, 32, ofp_action_types_flags) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestMeter(_ofp_header): |
| name = "OFPMP_REQUEST_METER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 9, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("meter_id", "ALL", ofp_meter), |
| XIntField("pad2", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMeterBandStats(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_METER_BAND_STATS" |
| fields_desc = [ LongField("packet_band_count", 0), |
| LongField("byte_band_count", 0) ] |
| |
| class OFPMeterStats(Packet): |
| def post_build(self, p, pay): |
| if self.len is None: |
| l = len(p)+len(pay) |
| p = p[:4] + struct.pack("!H", l) + p[6:] |
| return p + pay |
| name = "OFP_GROUP_STATS" |
| fields_desc = [ IntEnumField("meter_id", 1, ofp_meter), |
| ShortField("len", None), |
| XBitField("pad", 0, 48), |
| IntField("flow_count", 0), |
| LongField("packet_in_count", 0), |
| LongField("byte_in_count", 0), |
| IntField("duration_sec", 0), |
| IntField("duration_nsec", 0), |
| PacketListField("band_stats", None, OFPMeterBandStats, |
| length_from=lambda pkt:pkt.len-40) ] |
| |
| class MeterStatsPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_meter_stats_length(s): |
| return struct.unpack("!H", s[4:6])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| l = 0 |
| ret = b"" |
| remain = s |
| |
| while remain: |
| l = MeterStatsPacketListField._get_meter_stats_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPMeterStats(current) |
| lst.append(p) |
| |
| return remain + ret, lst |
| |
| class OFPMPReplyMeter(_ofp_header): |
| name = "OFPMP_REPLY_METER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 9, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| MeterStatsPacketListField("meter_stats", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestMeterConfig(_ofp_header): |
| name = "OFPMP_REQUEST_METER_CONFIG" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 10, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("meter_id", "ALL", ofp_meter), |
| XIntField("pad2", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMeterConfig(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_METER_CONFIG" |
| fields_desc = [ ShortField("length", None), |
| FlagsField("flags", 0, 16, [ "KBPS", |
| "PKTPS", |
| "BURST", |
| "STATS" ]), |
| IntEnumField("meter_id", 1, ofp_meter), |
| MeterBandPacketListField("bands", [], Packet, |
| length_from=lambda pkt:pkt.len-8) ] |
| |
| class MeterConfigPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_meter_config_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = MeterConfigPacketListField._get_meter_config_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPMeterConfig(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| class OFPMPReplyMeterConfig(_ofp_header): |
| name = "OFPMP_REPLY_METER_CONFIG" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 10, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| MeterConfigPacketListField("meter_configs", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestMeterFeatures(_ofp_header): |
| name = "OFPMP_REQUEST_METER_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 11, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyMeterFeatures(_ofp_header): |
| name = "OFPMP_REPLY_METER_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 11, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| IntField("max_meter", 0), |
| FlagsField("band_types", 0, 32, [ "DROP", |
| "DSCP_REMARK", |
| "EXPERIMENTER" ]), |
| FlagsField("capabilities", 0, 32, [ "KPBS", |
| "PKTPS", |
| "BURST", |
| "STATS" ]), |
| ByteField("max_bands", 0), |
| ByteField("max_color", 0), |
| XShortField("pad2", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| ####### table features for multipart messages ####### |
| |
| class _ofp_table_features_prop_header(Packet): |
| name = "Dummy OpenFlow Table Features Properties Header" |
| |
| def post_build(self, p, pay): |
| l = self.length |
| if l is None: |
| l = len(p)+len(pay) |
| p = p[:2] + struct.pack("!H", l) + p[4:] |
| # every message will be padded correctly |
| zero_bytes = (8 - l%8) % 8 |
| p += b"\x00" * zero_bytes |
| return p + pay |
| |
| def extract_padding(self, s): |
| l = self.length |
| zero_bytes = (8 - l%8) % 8 |
| return "", s |
| |
| |
| ofp_table_features_prop_types = { 0: "OFPTFPT_INSTRUCTIONS", |
| 1: "OFPTFPT_INSTRUCTIONS_MISS", |
| 2: "OFPTFPT_NEXT_TABLES", |
| 3: "OFPTFPT_NEXT_TABLES_MISS", |
| 4: "OFPTFPT_WRITE_ACTIONS", |
| 5: "OFPTFPT_WRITE_ACTIONS_MISS", |
| 6: "OFPTFPT_APPLY_ACTIONS", |
| 7: "OFPTFPT_APPLY_ACTIONS_MISS", |
| 8: "OFPTFPT_MATCH", |
| 10: "OFPTFPT_WILDCARDS", |
| 12: "OFPTFPT_WRITE_SETFIELD", |
| 13: "OFPTFPT_WRITE_SETFIELD_MISS", |
| 14: "OFPTFPT_APPLY_SETFIELD", |
| 15: "OFPTFPT_APPLY_SETFIELD_MISS", |
| 65534: "OFPTFPT_EXPERIMENTER", |
| 65535: "OFPTFPT_EXPERIMENTER_MISS" } |
| |
| class OFPTFPTInstructions(_ofp_table_features_prop_header): |
| name = "OFPTFPT_INSTRUCTIONS" |
| fields_desc = [ ShortField("type", 0), |
| ShortField("length", None), |
| InstructionIDPacketListField("instruction_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTInstructionsMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_INSTRUCTIONS_MISS" |
| fields_desc = [ ShortField("type", 1), |
| ShortField("length", None), |
| InstructionIDPacketListField("instruction_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTableID(Packet): |
| def extract_padding(self, s): |
| return "", s |
| name = "OFP_TABLE_ID" |
| fields_desc = [ ByteEnumField("table_id", 0, ofp_table) ] |
| |
| class OFPTFPTNextTables(_ofp_table_features_prop_header): |
| name = "OFPTFPT_NEXT_TABLES" |
| fields_desc = [ ShortField("type", 2), |
| ShortField("length", None), |
| PacketListField("next_table_ids", None, OFPTableID, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTNextTablesMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_NEXT_TABLES_MISS" |
| fields_desc = [ ShortField("type", 3), |
| ShortField("length", None), |
| PacketListField("next_table_ids", None, OFPTableID, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTWriteActions(_ofp_table_features_prop_header): |
| name = "OFPTFPT_WRITE_ACTIONS" |
| fields_desc = [ ShortField("type", 4), |
| ShortField("length", None), |
| ActionIDPacketListField("action_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTWriteActionsMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_WRITE_ACTIONS_MISS" |
| fields_desc = [ ShortField("type", 5), |
| ShortField("length", None), |
| ActionIDPacketListField("action_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTApplyActions(_ofp_table_features_prop_header): |
| name = "OFPTFPT_APPLY_ACTIONS" |
| fields_desc = [ ShortField("type", 6), |
| ShortField("length", None), |
| ActionIDPacketListField("action_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTApplyActionsMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_APPLY_ACTIONS_MISS" |
| fields_desc = [ ShortField("type", 7), |
| ShortField("length", None), |
| ActionIDPacketListField("action_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTMatch(_ofp_table_features_prop_header): |
| name = "OFPTFPT_MATCH" |
| fields_desc = [ ShortField("type", 8), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTWildcards(_ofp_table_features_prop_header): |
| name = "OFPTFPT_WILDCARDS" |
| fields_desc = [ ShortField("type", 10), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTWriteSetField(_ofp_table_features_prop_header): |
| name = "OFPTFPT_WRITE_SETFIELD" |
| fields_desc = [ ShortField("type", 12), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTWriteSetFieldMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_WRITE_SETFIELD_MISS" |
| fields_desc = [ ShortField("type", 13), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTApplySetField(_ofp_table_features_prop_header): |
| name = "OFPTFPT_APPLY_SETFIELD" |
| fields_desc = [ ShortField("type", 14), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTApplySetFieldMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_APPLY_SETFIELD_MISS" |
| fields_desc = [ ShortField("type", 15), |
| ShortField("length", None), |
| OXMIDPacketListField("oxm_ids", [], Packet, |
| length_from=lambda pkt:pkt.length-4) ] |
| |
| class OFPTFPTExperimenter(_ofp_table_features_prop_header): |
| name = "OFPTFPT_EXPERIMENTER" |
| fields_desc = [ ShortField("type", 65534), |
| ShortField("length", None), |
| IntField("experimenter", 0), |
| IntField("exp_type", 0), |
| PacketField("experimenter_data", None, Raw) ] |
| |
| class OFPTFPTExperimenterMiss(_ofp_table_features_prop_header): |
| name = "OFPTFPT_EXPERIMENTER_MISS" |
| fields_desc = [ ShortField("type", 65535), |
| ShortField("length", None), |
| IntField("experimenter", 0), |
| IntField("exp_type", 0), |
| PacketField("experimenter_data", None, Raw) ] |
| |
| ofp_table_features_prop_cls = { 0: OFPTFPTInstructions, |
| 1: OFPTFPTInstructionsMiss, |
| 2: OFPTFPTNextTables, |
| 3: OFPTFPTNextTablesMiss, |
| 4: OFPTFPTWriteActions, |
| 5: OFPTFPTWriteActionsMiss, |
| 6: OFPTFPTApplyActions, |
| 7: OFPTFPTApplyActionsMiss, |
| 8: OFPTFPTMatch, |
| 10: OFPTFPTWildcards, |
| 12: OFPTFPTWriteSetField, |
| 13: OFPTFPTWriteSetFieldMiss, |
| 14: OFPTFPTApplySetField, |
| 15: OFPTFPTApplySetFieldMiss, |
| 65534: OFPTFPTExperimenter, |
| 65535: OFPTFPTExperimenterMiss } |
| |
| class TableFeaturesPropPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_table_features_prop_length(s): |
| return struct.unpack("!H", s[2:4])[0] |
| |
| def m2i(self, pkt, s): |
| t = struct.unpack("!H", s[:2])[0] |
| return ofp_table_features_prop_cls.get(t, Raw)(s) |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain and len(remain) >= 4: |
| l = TableFeaturesPropPacketListField._get_table_features_prop_length(remain) |
| # add padding ! |
| lpad = l + (8 - l%8)%8 |
| if l < 4 or len(remain) < lpad: |
| # no zero length nor incoherent length |
| break |
| current = remain[:lpad] |
| remain = remain[lpad:] |
| p = self.m2i(pkt, current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| class OFPTableFeatures(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_TABLE_FEATURES" |
| fields_desc = [ ShortField("length", None), |
| ByteEnumField("table_id", 0, ofp_table), |
| XBitField("pad", 0, 40), |
| StrFixedLenField("table_name", "", 32), |
| LongField("metadata_match", 0), |
| LongField("metadata_write", 0), |
| IntEnumField("config", 0, { 0: "OFPTC_NO_MASK", |
| 3: "OFPTC_DEPRECATED_MASK" }), |
| IntField("max_entries", 0), |
| TableFeaturesPropPacketListField("properties", [], Packet, |
| length_from=lambda pkt:pkt.length-64) ] |
| |
| class TableFeaturesPacketListField(PacketListField): |
| |
| @staticmethod |
| def _get_table_features_length(s): |
| return struct.unpack("!H", s[:2])[0] |
| |
| def getfield(self, pkt, s): |
| lst = [] |
| remain = s |
| |
| while remain: |
| l = TableFeaturesPacketListField._get_table_features_length(remain) |
| current = remain[:l] |
| remain = remain[l:] |
| p = OFPTableFeatures(current) |
| lst.append(p) |
| |
| return remain, lst |
| |
| class OFPMPRequestTableFeatures(_ofp_header): |
| name = "OFPMP_REQUEST_TABLE_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 12, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| TableFeaturesPacketListField("table_features", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyTableFeatures(_ofp_header): |
| name = "OFPMP_REPLY_TABLE_FEATURES" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 12, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| TableFeaturesPacketListField("table_features", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| ############### end of table features ############### |
| |
| class OFPMPRequestPortDesc(_ofp_header): |
| name = "OFPMP_REQUEST_PORT_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 13, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntEnumField("port_no", 0, ofp_port_no), |
| XIntField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyPortDesc(_ofp_header): |
| name = "OFPMP_REPLY_PORT_DESC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 13, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| PacketListField("ports", None, OFPPort, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPMPRequestExperimenter(_ofp_header): |
| name = "OFPST_REQUEST_EXPERIMENTER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 18, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 65535, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_request_flags), |
| XIntField("pad1", 0), |
| IntField("experimenter", 0), |
| IntField("exp_type", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPMPReplyExperimenter(_ofp_header): |
| name = "OFPST_REPLY_EXPERIMENTER" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 19, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("mp_type", 65535, ofp_multipart_types), |
| FlagsField("flags", 0, 16, ofpmp_reply_flags), |
| XIntField("pad1", 0), |
| IntField("experimenter", 0), |
| IntField("exp_type", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| # ofp_multipart_request/reply_cls allows generic method OpenFlow() |
| # to choose the right class for dissection |
| ofp_multipart_request_cls = { 0: OFPMPRequestDesc, |
| 1: OFPMPRequestFlow, |
| 2: OFPMPRequestAggregate, |
| 3: OFPMPRequestTable, |
| 4: OFPMPRequestPortStats, |
| 5: OFPMPRequestQueue, |
| 6: OFPMPRequestGroup, |
| 7: OFPMPRequestGroupDesc, |
| 8: OFPMPRequestGroupFeatures, |
| 9: OFPMPRequestMeter, |
| 10: OFPMPRequestMeterConfig, |
| 11: OFPMPRequestMeterFeatures, |
| 12: OFPMPRequestTableFeatures, |
| 13: OFPMPRequestPortDesc, |
| 65535: OFPMPRequestExperimenter } |
| |
| ofp_multipart_reply_cls = { 0: OFPMPReplyDesc, |
| 1: OFPMPReplyFlow, |
| 2: OFPMPReplyAggregate, |
| 3: OFPMPReplyTable, |
| 4: OFPMPReplyPortStats, |
| 5: OFPMPReplyQueue, |
| 6: OFPMPReplyGroup, |
| 7: OFPMPReplyGroupDesc, |
| 8: OFPMPReplyGroupFeatures, |
| 9: OFPMPReplyMeter, |
| 10: OFPMPReplyMeterConfig, |
| 11: OFPMPReplyMeterFeatures, |
| 12: OFPMPReplyTableFeatures, |
| 13: OFPMPReplyPortDesc, |
| 65535: OFPMPReplyExperimenter } |
| |
| ############## end of OFPT_MULTIPART ################ |
| |
| class OFPTBarrierRequest(_ofp_header): |
| name = "OFPT_BARRIER_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 20, 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", 0x04, ofp_version), |
| ByteEnumField("type", 21, 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", 0x04, ofp_version), |
| ByteEnumField("type", 22, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("port_no", "ANY", ofp_port_no), |
| XIntField("pad", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTQueueGetConfigReply(_ofp_header): |
| name = "OFPT_QUEUE_GET_CONFIG_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 23, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("port", 0, ofp_port_no), |
| XIntField("pad", 0), |
| QueuePacketListField("queues", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTRoleRequest(_ofp_header): |
| name = "OFPT_ROLE_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 24, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("role", 0, { 0: "OFPCR_ROLE_NOCHANGE", |
| 1: "OFPCR_ROLE_EQUAL", |
| 2: "OFPCR_ROLE_MASTER", |
| 3: "OFPCR_ROLE_SLAVE" }), |
| XIntField("pad", 0), |
| LongField("generation_id", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTRoleReply(_ofp_header): |
| name = "OFPT_ROLE_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 25, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| IntEnumField("role", 0, { 0: "OFPCR_ROLE_NOCHANGE", |
| 1: "OFPCR_ROLE_EQUAL", |
| 2: "OFPCR_ROLE_MASTER", |
| 3: "OFPCR_ROLE_SLAVE" }), |
| XIntField("pad", 0), |
| LongField("generation_id", 0) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTGetAsyncRequest(_ofp_header): |
| name = "OFPT_GET_ASYNC_REQUEST" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 26, ofp_type), |
| ShortField("len", 8), |
| IntField("xid", 0) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| ofp_packet_in_reason = [ "NO_MATCH", |
| "ACTION", |
| "INVALID_TTL" ] |
| |
| ofp_port_reason = [ "ADD", |
| "DELETE", |
| "MODIFY" ] |
| |
| ofp_flow_removed_reason = [ "IDLE_TIMEOUT", |
| "HARD_TIMEOUT", |
| "DELETE", |
| "GROUP_DELETE" ] |
| |
| class OFPTGetAsyncReply(_ofp_header): |
| name = "OFPT_GET_ASYNC_REPLY" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 27, ofp_type), |
| ShortField("len", 32), |
| IntField("xid", 0), |
| FlagsField("packet_in_mask_master", 0, 32, ofp_packet_in_reason), |
| FlagsField("packet_in_mask_slave", 0, 32, ofp_packet_in_reason), |
| FlagsField("port_status_mask_master", 0, 32, ofp_port_reason), |
| FlagsField("port_status_mask_slave", 0, 32, ofp_port_reason), |
| FlagsField("flow_removed_mask_master", 0, 32, ofp_flow_removed_reason), |
| FlagsField("flow_removed_mask_slave", 0, 32, ofp_flow_removed_reason) ] |
| overload_fields = {TCP: {"dport": 6653}} |
| |
| class OFPTSetAsync(_ofp_header): |
| name = "OFPT_SET_ASYNC" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 28, ofp_type), |
| ShortField("len", 32), |
| IntField("xid", 0), |
| FlagsField("packet_in_mask_master", 0, 32, ofp_packet_in_reason), |
| FlagsField("packet_in_mask_slave", 0, 32, ofp_packet_in_reason), |
| FlagsField("port_status_mask_master", 0, 32, ofp_port_reason), |
| FlagsField("port_status_mask_slave", 0, 32, ofp_port_reason), |
| FlagsField("flow_removed_mask_master", 0, 32, ofp_flow_removed_reason), |
| FlagsField("flow_removed_mask_slave", 0, 32, ofp_flow_removed_reason) ] |
| overload_fields = {TCP: {"sport": 6653}} |
| |
| class OFPTMeterMod(_ofp_header): |
| name = "OFPT_METER_MOD" |
| fields_desc = [ ByteEnumField("version", 0x04, ofp_version), |
| ByteEnumField("type", 29, ofp_type), |
| ShortField("len", None), |
| IntField("xid", 0), |
| ShortEnumField("cmd", 0, { 0: "OFPMC_ADD", |
| 1: "OFPMC_MODIFY", |
| 2: "OFPMC_DELETE" }), |
| FlagsField("flags", 0, 16, [ "KBPS", |
| "PKTPS", |
| "BURST", |
| "STATS" ]), |
| IntEnumField("meter_id", 1, ofp_meter), |
| MeterBandPacketListField("bands", [], Packet, |
| length_from=lambda pkt:pkt.len-16) ] |
| overload_fields = {TCP: {"sport": 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: OFPTExperimenter, |
| 5: OFPTFeaturesRequest, |
| 6: OFPTFeaturesReply, |
| 7: OFPTGetConfigRequest, |
| 8: OFPTGetConfigReply, |
| 9: OFPTSetConfig, |
| 10: OFPTPacketIn, |
| 11: OFPTFlowRemoved, |
| 12: OFPTPortStatus, |
| 13: OFPTPacketOut, |
| 14: OFPTFlowMod, |
| 15: OFPTGroupMod, |
| 16: OFPTPortMod, |
| 17: OFPTTableMod, |
| #18: OFPTMultipartRequest, |
| #19: OFPTMultipartReply, |
| 20: OFPTBarrierRequest, |
| 21: OFPTBarrierReply, |
| 22: OFPTQueueGetConfigRequest, |
| 23: OFPTQueueGetConfigReply, |
| 24: OFPTRoleRequest, |
| 25: OFPTRoleReply, |
| 26: OFPTGetAsyncRequest, |
| 27: OFPTGetAsyncReply, |
| 28: OFPTSetAsync, |
| 29: OFPTMeterMod } |
| |
| 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 == 18: |
| mp_type = orb(payload[9]) |
| if mp_type == 255: mp_type = 65535 |
| return ofp_multipart_request_cls[mp_type] |
| elif of_type == 19: |
| mp_type = orb(payload[9]) |
| if mp_type == 255: mp_type = 65535 |
| return ofp_multipart_reply_cls[mp_type] |
| else: |
| return ofpt_cls[of_type] |
| else: |
| return TCP_guess_payload_class_copy(self, payload) |
| |
| TCP.guess_payload_class = OpenFlow |
