ofp13

package
v0.0.0-...-857358e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 2, 2019 License: MIT Imports: 3 Imported by: 12

Documentation

Index

Constants

View Source 
const (
	OFPP_MAX        = 0xffffff00
	OFPP_IN_PORT    = 0xfffffff8
	OFPP_TABLE      = 0xfffffff9
	OFPP_NORMAL     = 0xfffffffa
	OFPP_FLOOD      = 0xfffffffb
	OFPP_ALL        = 0xfffffffc
	OFPP_CONTROLLER = 0xfffffffd
	OFPP_LOCAL      = 0xfffffffe
	OFPP_ANY        = 0xffffffff
)
View Source 
const (
	OFPT_HELLO = iota
	OFPT_ERROR
	OFPT_ECHO_REQUEST
	OFPT_ECHO_REPLY
	OFPT_EXPERIMENTER
	OFPT_FEATURES_REQUEST
	OFPT_FEATURES_REPLY
	OFPT_GET_CONFIG_REQUEST
	OFPT_GET_CONFIG_REPLY
	OFPT_SET_CONFIG
	OFPT_PACKET_IN
	OFPT_FLOW_REMOVED
	OFPT_PORT_STATUS
	OFPT_PACKET_OUT
	OFPT_FLOW_MOD
	OFPT_GROUP_MOD
	OFPT_PORT_MOD
	OFPT_TABLE_MOD
	OFPT_MULTIPART_REQUEST
	OFPT_MULTIPART_REPLY
	OFPT_BARRIER_REQUEST
	OFPT_BARRIER_REPLY
	OFPT_QUEUE_GET_CONFIG_REQUEST
	OFPT_QUEUE_GET_CONFIG_REPLY
	OFPT_ROLE_REQUEST
	OFPT_ROLE_REPLY
	OFPT_GET_ASYNC_REQUEST
	OFPT_GET_ASYNC_REPLY
	OFPT_SET_ASYNC
	OFPT_METER_MOD
)
View Source 
const (
	OFPC_FLAG_NORMAL = 0
	OFPC_FLAG_DROP   = 1 << 0
	OFPC_FLAG_REASM  = 1 << 1
	OFPC_FLAG_MASK   = 3
)
View Source 
const (
	OFPTT_MAX = 0xfe
	OFPTT_ALL = 0xff
)
View Source 
const (
	OFPC_FLOW_STATS   = 1 << 0
	OFPC_TABLE_STATS  = 1 << 1
	OFPC_PORT_STATS   = 1 << 2
	OFPC_GROUP_STATS  = 1 << 3
	OFPC_IP_REASM     = 1 << 5
	OFPC_QUEUE_STATS  = 1 << 6
	OFPC_PORT_BLOCKED = 1 << 8
)
View Source 
const (
	OFPPC_PORT_DOWN    = 1 << 0
	OFPPC_NO_RECV      = 1 << 2
	OFPPC_NO_FWD       = 1 << 5
	OFPPC_NO_PACKET_IN = 1 << 6
)
View Source 
const (
	OFPPS_LINK_DOWN = 1 << 0
	OFPPS_BLOCKED   = 1 << 1
	OFPPS_LIVE      = 1 << 2
)
View Source 
const (
	OFPPF_10MB_HD  = 1 << 0
	OFPPF_10MB_FD  = 1 << 1
	OFPPF_100MB_HD = 1 << 2
	OFPPF_100MB_FD = 1 << 3
	OFPPF_1GB_HD   = 1 << 4
	OFPPF_1GB_FD   = 1 << 5
	OFPPF_10GB_FD  = 1 << 6
	OFPPF_40GB_FD  = 1 << 7
	OFPPF_100GB_FD = 1 << 8
	OFPPF_1TB_FD   = 1 << 9
	OFPPF_OTHER    = 1 << 10

	OFPPF_COPPER     = 1 << 11
	OFPPF_FIBER      = 1 << 12
	OFPPF_AUTONEG    = 1 << 13
	OFPPF_PAUSE      = 1 << 14
	OFPPF_PAUSE_ASYM = 1 << 15
)
View Source 
const (
	OFPPR_ADD = iota
	OFPPR_DELETE
	OFPPR_MODIFY
)

ofp_port_reason

View Source 
const (
	OFPMT_STANDARD = iota
	OFPMT_OXM
)

ofp_match_type

View Source 
const (
	OFPXMC_NXM_0          = 0x0000
	OFPXMC_NXM_1          = 0x0001
	OFPXMC_OPENFLOW_BASIC = 0x8000
	OFPXMC_EXPERIMENTER   = 0xffff
)

ofp_oxm_class

View Source 
const (
	OFPXMT_OFB_IN_PORT = iota
	OFPXMT_OFB_IN_PHY_PORT
	OFPXMT_OFB_METADATA
	OFPXMT_OFB_ETH_DST
	OFPXMT_OFB_ETH_SRC
	OFPXMT_OFB_ETH_TYPE
	OFPXMT_OFB_VLAN_VID
	OFPXMT_OFB_VLAN_PCP
	OFPXMT_OFB_IP_DSCP
	OFPXMT_OFB_IP_ECN
	OFPXMT_OFB_IP_PROTO
	OFPXMT_OFB_IPV4_SRC
	OFPXMT_OFB_IPV4_DST
	OFPXMT_OFB_TCP_SRC
	OFPXMT_OFB_TCP_DST
	OFPXMT_OFB_UDP_SRC
	OFPXMT_OFB_UDP_DST
	OFPXMT_OFB_SCTP_SRC
	OFPXMT_OFB_SCTP_DST
	OFPXMT_OFB_ICMPV4_TYPE
	OFPXMT_OFB_ICMPV4_CODE
	OFPXMT_OFB_ARP_OP
	OFPXMT_OFB_ARP_SPA
	OFPXMT_OFB_ARP_TPA
	OFPXMT_OFB_ARP_SHA
	OFPXMT_OFB_ARP_THA
	OFPXMT_OFB_IPV6_SRC
	OFPXMT_OFB_IPV6_DST
	OFPXMT_OFB_IPV6_FLABEL
	OFPXMT_OFB_ICMPV6_TYPE
	OFPXMT_OFB_ICMPV6_CODE
	OFPXMT_OFB_IPV6_ND_TARGET
	OFPXMT_OFB_IPV6_ND_SLL
	OFPXMT_OFB_IPV6_ND_TLL
	OFPXMT_OFB_MPLS_LABEL
	OFPXMT_OFB_MPLS_TC
	OFPXMT_OFB_MPLS_BOS
	OFPXMT_OFB_PBB_ISID
	OFPXMT_OFB_TUNNEL_ID
	OFPXMT_OFB_IPV6_EXTHDR
)

oxm_ofb_match_fields

View Source 
const (
	OFPVID_PRESENT = 0x1000
	OFPVID_NONE    = 0x0000
)
View Source 
const (
	OFPIEH_NONEXT = 1 << 0
	OFPIEH_ESP    = 1 << 1
	OFPIEH_AUTH   = 1 << 2
	OFPIEH_DEST   = 1 << 3
	OFPIEH_FRAG   = 1 << 4
	OFPIEH_ROUTER = 1 << 5
	OFPIEH_HOP    = 1 << 6
	OFPIEH_UNREP  = 1 << 7
	OFPIEH_UNSEQ  = 1 << 8
)

ofp_ipv6exthdr_flags

View Source 
const (
	OFPAT_OUTPUT       = 0
	OFPAT_COPY_TTL_OUT = 11
	OFPAT_COPY_TTL_IN  = 12
	OFPAT_SET_MPLS_TTL = 15
	OFPAT_DEC_MPLS_TTL = 16
	OFPAT_PUSH_VLAN    = 17
	OFPAT_POP_VLAN     = 18
	OFPAT_PUSH_MPLS    = 19
	OFPAT_POP_MPLS     = 20
	OFPAT_SET_QUEUE    = 21
	OFPAT_GROUP        = 22
	OFPAT_SET_NW_TTL   = 23
	OFPAT_DEC_NW_TTL   = 24
	OFPAT_SET_FIELD    = 25
	OFPAT_PUSH_PBB     = 26
	OFPAT_POP_PBB      = 27
	OFPAT_EXPERIMENTER = 0xffff
)

ofp_action_type

View Source 
const (
	OFPCML_MAX       = 0xffe5
	OFPCML_NO_BUFFER = 0xffff
)

ofp_controller_max_len

View Source 
const (
	OFPIT_GOTO_TABLE     = 1
	OFPIT_WRITE_METADATA = 2
	OFPIT_WRITE_ACTIONS  = 3
	OFPIT_APPLY_ACTIONS  = 4
	OFPIT_CLEAR_ACTIONS  = 5
	OFPIT_METER          = 6
	OFPIT_EXPERIMENTER   = 0xffff
)

ofp_instruction_type

View Source 
const (
	OFPFC_ADD = iota
	OFPFC_MODIFY
	OFPFC_MODIFY_STRICT

	OFPFC_DELETE
	OFPFC_DELETE_STRICT
)
View Source 
const (
	OFPFF_SEND_FLOW_REM = 1 << 0
	OFPFF_CHECK_OVERLAP = 1 << 1
	OFPFF_RESET_COUNTS  = 1 << 2
	OFPFF_NO_PKT_COUNTS = 1 << 3
	OFPFF_NO_BYT_COUNTS = 1 << 4
)

ofp_flow_mod_flags

View Source 
const (
	OFPG_MAX = 0xffffff00
	OFPG_ALL = 0xfffffffc
	OFPG_ANY = 0xffffffff
)

ofp_group

View Source 
const (
	OFPGC_ADD = iota
	OFPGC_MODIFY
	OFPGC_DELETE
)

ofp_group_mod_command

View Source 
const (
	OFPGT_ALL = iota
	OFPGT_SELECT
	OFPGT_INDIRECT
	OFPGT_FF
)

ofp_group_type

View Source 
const (
	OFPR_NO_MATCH = iota
	OFPR_ACTION
	OFPR_INVALID_TTL
)

ofp_packet_in_reason

View Source 
const (
	OFPRR_IDLE_TIMEOUT = iota
	OFPRR_HARD_TIMEOUT
	OFPRR_DELETE
	OFPRR_GROUP_DELETE
)

ofp_flow_removed_reason

View Source 
const (
	OFPM_MAX        = 0xffff0000
	OFPM_SLOWPATH   = 0xfffffffd
	OFPM_CONTROLLER = 0xfffffffe
	OFPM_ALL        = 0xffffffff
)

ofp_meter

View Source 
const (
	OFPMBT_DROP         = 1
	OFPMBT_DSCP_REMARK  = 2
	OFPMBT_EXPERIMENTER = 0xFFFF
)

ofp_meter_band_type

View Source 
const (
	OFPMC_ADD = iota
	OFPMC_MODIFY
	OFPMC_DELETE
)

ofp_meter_mod_command

View Source 
const (
	OFPMF_KBPS  = 1 << 0
	OFPMF_PKTPS = 1 << 1
	OFPMF_BURST = 1 << 2
	OFPMF_STATS = 1 << 3
)

ofp_meter_flags

View Source 
const (
	OFPET_HELLO_FAILED = iota
	OFPET_BAD_REQUEST
	OFPET_BAD_ACTION
	OFPET_BAD_INSTRUCTION
	OFPET_BAD_MATCH
	OFPET_FLOW_MOD_FAILED
	OFPET_GROUP_MOD_FAILED
	OFPET_PORT_MOD_FAILED
	OFPET_TABLE_MOD_FAILED
	OFPET_QUEUE_OP_FAILED
	OFPET_SWITCH_CONFIG_FAILED
	OFPET_ROLE_REQUEST_FAILED
	OFPET_METER_MOD_FAILED
	OFPET_TABLE_FEATURES_FAILED
	OFPET_EXPERIMENTER = 0xffff
)

ofp_error_type

View Source 
const (
	OFPHFC_INCOMPATIBLE = iota
	OFPHFC_EPERM
)

ofp_hello_failed_code

View Source 
const (
	OFPBRC_BAD_VERSION = iota
	OFPBRC_BAD_TYPE
	OFPBRC_BAD_MULTIPART
	OFPBRC_BAD_EXPERIMENTER
	OFPBRC_BAD_EXP_TYPE
	OFPBRC_EPERM
	OFPBRC_BAD_LEN
	OFPBRC_BUFFER_EMPTY
	OFPBRC_BUFFER_UNKNOWN
	OFPBRC_BAD_TABLE_ID
	OFPBRC_IS_SLAVE
	OFPBRC_BAD_PORT
	OFPBRC_BAD_PACKET
	OFPBRC_MULTIPART_BUFFER_OVERFLOW
)

ofp_bad_request_code

View Source 
const (
	OFPBAC_BAD_TYPE = iota
	OFPBAC_BAD_LEN
	OFPBAC_BAD_EXPERIMENTER
	OFPBAC_BAD_EXP_TYPE
	OFPBAC_BAD_OUT_PORT
	OFPBAC_BAD_ARGUMENT
	OFPBAC_EPERM
	OFPBAC_TOO_MANY
	OFPBAC_BAD_QUEUE
	OFPBAC_BAD_OUT_GROUP
	OFPBAC_MATCH_INCONSISTENT
	OFPBAC_UNSUPPORTED_ORDER
	OFPBAC_BAD_TAG
	OFPBAC_BAD_SET_TYPE
	OFPBAC_BAD_SET_LEN
	OFPBAC_BAD_SET_ARGUMENT
)

ofp_bad_action_code

View Source 
const (
	OFPBIC_UNKNOWN_INST = iota
	OFPBIC_UNSUP_INST
	OFPBIC_BAD_TABLE_ID
	OFPBIC_UNSUP_METADATA
	OFPBIC_UNSUP_METADATA_MASK
	OFPBIC_BAD_EXPERIMENTER
	OFPBIC_BAD_EXP_TYPE
	OFPBIC_BAD_LEN
	OFPBIC_EPERM
)

ofp_bad_instruction_code

View Source 
const (
	OFPBMC_BAD_TYPE = iota
	OFPBMC_BAD_LEN
	OFPBMC_BAD_TAG
	OFPBMC_BAD_DL_ADDR_MASK
	OFPBMC_BAD_NW_ADDR_MASK
	OFPBMC_BAD_WILDCARDS
	OFPBMC_BAD_FIELD
	OFPBMC_BAD_VALUE
	OFPBMC_BAD_MASK
	OFPBMC_BAD_PREREQ
	OFPBMC_DUP_FIELD
	OFPBMC_EPERM
)

ofp_bad_match_code

View Source 
const (
	OFPFMFC_UNKNOWN = iota
	OFPFMFC_TABLE_FULL
	OFPFMFC_BAD_TABLE_ID
	OFPFMFC_OVERLAP
	OFPFMFC_EPERM
	OFPFMFC_BAD_TIMEOUT
	OFPFMFC_BAD_COMMAND
	OFPFMFC_BAD_FLAGS
)

ofp_flow_mod_failed_code

View Source 
const (
	OFPGMFC_GROUP_EXISTS = iota
	OFPGMFC_INVALID_GROUP
	OFPGMFC_WEIGHT_UNSUPPORTED
	OFPGMFC_OUT_OF_GROUPS
	OFPGMFC_OUT_OF_BUCKETS
	OFPGMFC_CHAINING_UNSUPPORTED
	OFPGMFC_WATCH_UNSUPPORTED
	OFPGMFC_LOOP
	OFPGMFC_UNKNOWN_GROUP
	OFPGMFC_CHAINED_GROUP
	OFPGMFC_BAD_TYPE
	OFPGMFC_BAD_COMMAND
	OFPGMFC_BAD_BUCKET
	OFPGMFC_BAD_WATCH
	OFPGMFC_EPERM
)

ofp_group_mod_failed_code

View Source 
const (
	OFPPMFC_BAD_PORT = iota
	OFPPMFC_BAD_HW_ADDR
	OFPPMFC_BAD_CONFIG
	OFPPMFC_BAD_ADVERTISE
	OFPPMFC_EPERM
)

ofp_port_mod_failed_code

View Source 
const (
	OFPTMFC_BAD_TABLE = iota
	OFPTMFC_BAD_CONFIG
	OFPTMFC_EPERM
)

ofp_table_mod_faled_code

View Source 
const (
	OFPQOFC_BAD_PORT = iota
	OFPQOFC_BAD_QUEUE
	OFPQOFC_EPERM
)

ofp_queue_op_failed_code

View Source 
const (
	OFPSCFC_BAD_FLAGS = iota
	OFPSCFC_BAD_LEN
	OFPSCFC_EPERM
)

ofp_switch_config_failed_code

View Source 
const (
	OFPRRFC_STALE = iota
	OFPRRFC_UNSUP
	OFPRRFC_BAD_ROLE
)

ofp_role_request_failed_code

View Source 
const (
	OFPMMFC_UNKNOWN = iota
	OFPMMFC_METER_EXISTS
	OFPMMFC_INVALID_METER
	OFPMMFC_UNKNOWN_METER
	OFPMMFC_BAD_COMMAND
	OFPMMFC_BAD_FLAGS
	OFPMMFC_BAD_RATE
	OFPMMFC_BAD_BURST
	OFPMMFC_BAD_BAND
	OFPMMFC_BAD_BAND_VALUE
	OFPMMFC_OUT_OF_METERS
	OFPMMFC_OUT_OF_BANDS
)

ofp_meter_mod_failed_code

View Source 
const (
	OFPTFFC_BAD_TABLE = iota
	OFPTFFC_BAD_METADATA
	OFPTFFC_BAD_TYPE
	OFPTFFC_BAD_LEN
	OFPTFFC_BAD_ARGUMENT
	OFPTFFC_EPERM
)

ofp_table_features_failed_code

View Source 
const (
	OFPMP_DESC = iota
	OFPMP_FLOW
	OFPMP_AGGREGATE
	OFPMP_TABLE
	OFPMP_PORT_STATS
	OFPMP_QUEUE
	OFPMP_GROUP
	OFPMP_GROUP_DESC
	OFPMP_GROUP_FEATURES
	OFPMP_METER
	OFPMP_METER_CONFIG
	OFPMP_METER_FEATURES
	OFPMP_TABLE_FEATURES
	OFPMP_PORT_DESC
	OFPMP_EXPERIMENTER = 0xffff
)

ofp_multipart_type

View Source 
const (
	OFPTFPT_INSTRUCTIONS        = 0
	OFPTFPT_INSTRUCTIONS_MISS   = 1
	OFPTFPT_NEXT_TABLES         = 2
	OFPTFPT_NEXT_TABLES_MISS    = 3
	OFPTFPT_WRITE_ACTIONS       = 4
	OFPTFPT_WRITE_ACTIONS_MISS  = 5
	OFPTFPT_APPLY_ACTIONS       = 6
	OFPTFPT_APPLY_ACTIONS_MISS  = 7
	OFPTFPT_MATCH               = 8
	OFPTFPT_WILDCARDS           = 10
	OFPTFPT_WRITE_SETFIELD      = 12
	OFPTFPT_WRITE_SETFIELD_MISS = 13
	OFPTFPT_APPLY_SETFIELD      = 14
	OFPTFPT_APPLY_SETFIELD_MISS = 15
	OFPTFPT_EXPERIMENTER        = 0xfffe
	OFPTFPT_EXPERIMENTER_MISS   = 0xffff
)

ofp_table_feature_prop_type

View Source 
const (
	OFPGC_SELECT_WEIGHT   = 1 << 0
	OFPGC_SELECT_LIVENESS = 1 << 1
	OFPGC_CHAINING        = 1 << 2
	OFPGC_CHAINING_CHECKS = 1 << 3
)

ofp_group_capabilities

View Source 
const (
	OFPQT_MIN_RATE     = 1
	OFPQT_MAX_RATE     = 2
	OFPQT_EXPERIMENTER = 0xffff
)

ofp_queue_properties

View Source 
const (
	OFPCR_ROLE_NOCHANGE = 0
	OFPCR_ROLE_EQUAL    = 1
	OFPCT_ROLE_MASTER   = 2
	OFPCR_ROLE_SLAVE    = 3
)

ofp_controller_role

View Source 
const DESC_STR_LEN = 256
View Source 
const (
	OFPHET_VERSIONBITMAP = 1
)
View Source 
const (
	OFPMPF_REPLY_MORE = 1 << 0
)

ofp_multipart_reply_flags

View Source 
const (
	OFPMPF_REQ_MORE = 1 << 0
)

ofp_multipart_request_flags

View Source 
const OFPQ_ALL = 0xffffffff
View Source 
const OFPQ_MAX_RATE_UNCFG = 0xffff
View Source 
const OFPQ_MIN_RATE_UNCFG = 0xffff
View Source 
const (
	OFPTC_DEPRECATED_MASK = 3
)
View Source 
const (
	OFP_DEFAULT_PRIORITY = 0x8000
)
View Source 
const OFP_ETH_ALEN = 6
View Source 
const (
	OFP_FLOW_PERMANENT = 0
)
View Source 
const OFP_MAX_PORT_NAME_LEN = 16
View Source 
const OFP_MAX_TABLE_NAME_LEN = 32
View Source 
const OFP_NO_BUFFER = 0xffffffff
View Source 
const (
	OFP_VLAN_NONE = OFPVID_NONE
)
View Source 
const SERIAL_NUM_LEN = 32

Variables

View Source 
var OFPXMT_OFB_ALL uint64 = ((1 << 40) - 1)
View Source 
var OXM_OF_ARP_OP = oxmHeader(0x8000, OFPXMT_OFB_ARP_OP, 2)
View Source 
var OXM_OF_ARP_SHA = oxmHeader(0x8000, OFPXMT_OFB_ARP_SHA, 6)
View Source 
var OXM_OF_ARP_SPA = oxmHeader(0x8000, OFPXMT_OFB_ARP_SPA, 4)
View Source 
var OXM_OF_ARP_SPA_W = oxmHeaderW(0x8000, OFPXMT_OFB_ARP_SPA, 4)
View Source 
var OXM_OF_ARP_THA = oxmHeader(0x8000, OFPXMT_OFB_ARP_THA, 6)
View Source 
var OXM_OF_ARP_TPA = oxmHeader(0x8000, OFPXMT_OFB_ARP_TPA, 4)
View Source 
var OXM_OF_ARP_TPA_W = oxmHeaderW(0x8000, OFPXMT_OFB_ARP_TPA, 4)
View Source 
var OXM_OF_ETH_DST = oxmHeader(0x8000, OFPXMT_OFB_ETH_DST, 6)
View Source 
var OXM_OF_ETH_DST_W = oxmHeaderW(0x8000, OFPXMT_OFB_ETH_DST, 6)
View Source 
var OXM_OF_ETH_SRC = oxmHeader(0x8000, OFPXMT_OFB_ETH_SRC, 6)
View Source 
var OXM_OF_ETH_SRC_W = oxmHeaderW(0x8000, OFPXMT_OFB_ETH_SRC, 6)
View Source 
var OXM_OF_ETH_TYPE = oxmHeader(0x8000, OFPXMT_OFB_ETH_TYPE, 2)
View Source 
var OXM_OF_ICMPV4_CODE = oxmHeader(0x8000, OFPXMT_OFB_ICMPV4_CODE, 1)
View Source 
var OXM_OF_ICMPV4_TYPE = oxmHeader(0x8000, OFPXMT_OFB_ICMPV4_TYPE, 1)
View Source 
var OXM_OF_ICMPV6_CODE = oxmHeader(0x8000, OFPXMT_OFB_ICMPV6_CODE, 1)
View Source 
var OXM_OF_ICMPV6_TYPE = oxmHeader(0x8000, OFPXMT_OFB_ICMPV6_TYPE, 1)
View Source 
var OXM_OF_IN_PHY_PORT = oxmHeader(0x8000, OFPXMT_OFB_IN_PHY_PORT, 4)
View Source 
var OXM_OF_IN_PORT = oxmHeader(0x8000, OFPXMT_OFB_IN_PORT, 4)
View Source 
var OXM_OF_IPV4_DST = oxmHeader(0x8000, OFPXMT_OFB_IPV4_DST, 4)
View Source 
var OXM_OF_IPV4_DST_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV4_DST, 4)
View Source 
var OXM_OF_IPV4_SRC = oxmHeader(0x8000, OFPXMT_OFB_IPV4_SRC, 4)
View Source 
var OXM_OF_IPV4_SRC_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV4_SRC, 4)
View Source 
var OXM_OF_IPV6_DST = oxmHeader(0x8000, OFPXMT_OFB_IPV6_DST, 16)
View Source 
var OXM_OF_IPV6_DST_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV6_DST, 16)
View Source 
var OXM_OF_IPV6_EXTHDR = oxmHeader(0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
View Source 
var OXM_OF_IPV6_EXTHDR_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV6_EXTHDR, 2)
View Source 
var OXM_OF_IPV6_FLABEL = oxmHeader(0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
View Source 
var OXM_OF_IPV6_FLABEL_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV6_FLABEL, 4)
View Source 
var OXM_OF_IPV6_ND_SLL = oxmHeader(0x8000, OFPXMT_OFB_IPV6_ND_SLL, 6)
View Source 
var OXM_OF_IPV6_ND_TARGET = oxmHeader(0x8000, OFPXMT_OFB_IPV6_ND_TARGET, 16)
View Source 
var OXM_OF_IPV6_ND_TLL = oxmHeader(0x8000, OFPXMT_OFB_IPV6_ND_TLL, 6)
View Source 
var OXM_OF_IPV6_SRC = oxmHeader(0x8000, OFPXMT_OFB_IPV6_SRC, 16)
View Source 
var OXM_OF_IPV6_SRC_W = oxmHeaderW(0x8000, OFPXMT_OFB_IPV6_SRC, 16)
View Source 
var OXM_OF_IP_DSCP = oxmHeader(0x8000, OFPXMT_OFB_IP_DSCP, 1)
View Source 
var OXM_OF_IP_ECN = oxmHeader(0x8000, OFPXMT_OFB_IP_ECN, 1)
View Source 
var OXM_OF_IP_PROTO = oxmHeader(0x8000, OFPXMT_OFB_IP_PROTO, 1)
View Source 
var OXM_OF_METADATA = oxmHeader(0x8000, OFPXMT_OFB_METADATA, 8)
View Source 
var OXM_OF_METADATA_W = oxmHeaderW(0x8000, OFPXMT_OFB_METADATA, 8)
View Source 
var OXM_OF_MPLS_BOS = oxmHeader(0x8000, OFPXMT_OFB_MPLS_BOS, 1)
View Source 
var OXM_OF_MPLS_LABEL = oxmHeader(0x8000, OFPXMT_OFB_MPLS_LABEL, 4)
View Source 
var OXM_OF_MPLS_TC = oxmHeader(0x8000, OFPXMT_OFB_MPLS_TC, 1)
View Source 
var OXM_OF_PBB_ISID = oxmHeader(0x8000, OFPXMT_OFB_PBB_ISID, 3)
View Source 
var OXM_OF_PBB_ISID_W = oxmHeaderW(0x8000, OFPXMT_OFB_PBB_ISID, 3)
View Source 
var OXM_OF_SCTP_DST = oxmHeader(0x8000, OFPXMT_OFB_SCTP_DST, 2)
View Source 
var OXM_OF_SCTP_SRC = oxmHeader(0x8000, OFPXMT_OFB_SCTP_SRC, 2)
View Source 
var OXM_OF_TCP_DST = oxmHeader(0x8000, OFPXMT_OFB_TCP_DST, 2)
View Source 
var OXM_OF_TCP_SRC = oxmHeader(0x8000, OFPXMT_OFB_TCP_SRC, 2)
View Source 
var OXM_OF_TUNNEL_ID = oxmHeader(0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
View Source 
var OXM_OF_TUNNEL_ID_W = oxmHeaderW(0x8000, OFPXMT_OFB_TUNNEL_ID, 8)
View Source 
var OXM_OF_UDP_DST = oxmHeader(0x8000, OFPXMT_OFB_UDP_DST, 2)
View Source 
var OXM_OF_UDP_SRC = oxmHeader(0x8000, OFPXMT_OFB_UDP_SRC, 2)
View Source 
var OXM_OF_VLAN_PCP = oxmHeader(0x8000, OFPXMT_OFB_VLAN_PCP, 1)
View Source 
var OXM_OF_VLAN_VID = oxmHeader(0x8000, OFPXMT_OFB_VLAN_VID, 2)
View Source 
var OXM_OF_VLAN_VID_W = oxmHeaderW(0x8000, OFPXMT_OFB_VLAN_VID, 2)

Functions

This section is empty.

Types

type OFMessage 

type OFMessage interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
}

func Parse 

func Parse(packet []byte) (msg OFMessage)

type OfpAction 

type OfpAction interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
	OfpActionType() uint16
}

func ParseAction 

func ParseAction(packet []byte) (action OfpAction)

* OfpAction Parser

type OfpActionCopyTtlIn 

type OfpActionCopyTtlIn struct {
	ActionHeader OfpActionHeader
	Pad          [4]uint8
}

func NewOfpActionCopyTtlIn 

func NewOfpActionCopyTtlIn() *OfpActionCopyTtlIn

* OfpActionCopyTtlIn

func (*OfpActionCopyTtlIn) OfpActionType 

func (a *OfpActionCopyTtlIn) OfpActionType() uint16

func (*OfpActionCopyTtlIn) Parse 

func (a *OfpActionCopyTtlIn) Parse(packet []byte)

func (*OfpActionCopyTtlIn) Serialize 

func (a *OfpActionCopyTtlIn) Serialize() []byte

func (*OfpActionCopyTtlIn) Size 

func (a *OfpActionCopyTtlIn) Size() int

type OfpActionCopyTtlOut 

type OfpActionCopyTtlOut struct {
	ActionHeader OfpActionHeader
	Pad          [4]uint8
}

func NewOfpActionCopyTtlOut 

func NewOfpActionCopyTtlOut() *OfpActionCopyTtlOut

* OfpActionCopyTtlOut

func (*OfpActionCopyTtlOut) OfpActionType 

func (a *OfpActionCopyTtlOut) OfpActionType() uint16

func (*OfpActionCopyTtlOut) Parse 

func (a *OfpActionCopyTtlOut) Parse(packet []byte)

func (*OfpActionCopyTtlOut) Serialize 

func (a *OfpActionCopyTtlOut) Serialize() []byte

func (*OfpActionCopyTtlOut) Size 

func (a *OfpActionCopyTtlOut) Size() int

type OfpActionDecMplsTtl 

type OfpActionDecMplsTtl struct {
	ActionHeader OfpActionHeader
	Pad          [4]uint8
}

func NewOfpActionDecMplsTtl 

func NewOfpActionDecMplsTtl() *OfpActionDecMplsTtl

* OfpActionDecMplsTtl

func (*OfpActionDecMplsTtl) OfpActionType 

func (a *OfpActionDecMplsTtl) OfpActionType() uint16

func (*OfpActionDecMplsTtl) Parse 

func (a *OfpActionDecMplsTtl) Parse(packet []byte)

func (*OfpActionDecMplsTtl) Serialize 

func (a *OfpActionDecMplsTtl) Serialize() []byte

func (*OfpActionDecMplsTtl) Size 

func (a *OfpActionDecMplsTtl) Size() int

type OfpActionDecNwTtl 

type OfpActionDecNwTtl struct {
	ActionHeader OfpActionHeader
	Pad          [4]uint8
}

func NewOfpActionDecNwTtl 

func NewOfpActionDecNwTtl() *OfpActionDecNwTtl

* OfpActionDecNwTtl

func (*OfpActionDecNwTtl) OfpActionType 

func (a *OfpActionDecNwTtl) OfpActionType() uint16

func (*OfpActionDecNwTtl) Parse 

func (a *OfpActionDecNwTtl) Parse(packet []byte)

func (*OfpActionDecNwTtl) Serialize 

func (a *OfpActionDecNwTtl) Serialize() []byte

func (*OfpActionDecNwTtl) Size 

func (a *OfpActionDecNwTtl) Size() int

type OfpActionExperimenter 

type OfpActionExperimenter struct {
	ActionHeader OfpActionHeader
	Experimenter uint32
}

func NewOfpActionExperimenter 

func NewOfpActionExperimenter(experimenter uint32) *OfpActionExperimenter

* OfpActionExperimenter

func (*OfpActionExperimenter) OfpActionType 

func (a *OfpActionExperimenter) OfpActionType() uint16

func (*OfpActionExperimenter) Parse 

func (a *OfpActionExperimenter) Parse(packet []byte)

func (*OfpActionExperimenter) Serialize 

func (a *OfpActionExperimenter) Serialize() []byte

func (*OfpActionExperimenter) Size 

func (a *OfpActionExperimenter) Size() int

type OfpActionGroup 

type OfpActionGroup struct {
	ActionHeader OfpActionHeader
	GroupId      uint32
}

func NewOfpActionGroup 

func NewOfpActionGroup(id uint32) *OfpActionGroup

* OfpActionGroup

func (*OfpActionGroup) OfpActionType 

func (a *OfpActionGroup) OfpActionType() uint16

func (*OfpActionGroup) Parse 

func (a *OfpActionGroup) Parse(packet []byte)

func (*OfpActionGroup) Serialize 

func (a *OfpActionGroup) Serialize() []byte

func (*OfpActionGroup) Size 

func (a *OfpActionGroup) Size() int

type OfpActionHeader 

type OfpActionHeader struct {
	Type   uint16
	Length uint16
}

func NewOfpActionHeader 

func NewOfpActionHeader(t uint16, length uint16) OfpActionHeader

*************************************************** 

OfpAction

***************************************************

func (*OfpActionHeader) Parse 

func (h *OfpActionHeader) Parse(packet []byte)

func (*OfpActionHeader) Serialize 

func (h *OfpActionHeader) Serialize() []byte

func (*OfpActionHeader) Size 

func (h *OfpActionHeader) Size() int

type OfpActionOutput 

type OfpActionOutput struct {
	ActionHeader OfpActionHeader
	Port         uint32
	MaxLen       uint16
	Pad          [6]uint8
}

func NewOfpActionOutput 

func NewOfpActionOutput(port uint32, max_len uint16) *OfpActionOutput

* OfpActionOutput

func (*OfpActionOutput) OfpActionType 

func (a *OfpActionOutput) OfpActionType() uint16

func (*OfpActionOutput) Parse 

func (a *OfpActionOutput) Parse(packet []byte)

func (*OfpActionOutput) Serialize 

func (a *OfpActionOutput) Serialize() []byte

func (*OfpActionOutput) Size 

func (a *OfpActionOutput) Size() int

type OfpActionPop 

type OfpActionPop struct {
	ActionHeader OfpActionHeader
	EtherType    uint16
	Pad          [2]uint8
}

func NewOfpActionPopMpls 

func NewOfpActionPopMpls(etherType uint16) *OfpActionPop

func NewOfpActionPopPbb 

func NewOfpActionPopPbb(etherType uint16) *OfpActionPop

func NewOfpActionPopVlan 

func NewOfpActionPopVlan(etherType uint16) *OfpActionPop

* OfpActionPop

func (*OfpActionPop) OfpActionType 

func (a *OfpActionPop) OfpActionType() uint16

func (*OfpActionPop) Parse 

func (a *OfpActionPop) Parse(packet []byte)

func (*OfpActionPop) Serialize 

func (a *OfpActionPop) Serialize() []byte

func (*OfpActionPop) Size 

func (a *OfpActionPop) Size() int

type OfpActionPush 

type OfpActionPush struct {
	ActionHeader OfpActionHeader
	EtherType    uint16
	Pad          [2]uint8
}

func NewOfpActionPush 

func NewOfpActionPush(actionType uint16, etherType uint16) *OfpActionPush

func NewOfpActionPushMpls 

func NewOfpActionPushMpls() *OfpActionPush

func NewOfpActionPushPbb 

func NewOfpActionPushPbb() *OfpActionPush

func NewOfpActionPushVlan 

func NewOfpActionPushVlan() *OfpActionPush

func (*OfpActionPush) OfpActionType 

func (a *OfpActionPush) OfpActionType() uint16

func (*OfpActionPush) Parse 

func (a *OfpActionPush) Parse(packet []byte)

func (*OfpActionPush) Serialize 

func (a *OfpActionPush) Serialize() []byte

func (*OfpActionPush) Size 

func (a *OfpActionPush) Size() int

type OfpActionSetField 

type OfpActionSetField struct {
	ActionHeader OfpActionHeader
	Oxm          OxmField
}

func NewOfpActionSetField 

func NewOfpActionSetField(oxm OxmField) *OfpActionSetField

* OfpActionSetField

func (*OfpActionSetField) OfpActionType 

func (a *OfpActionSetField) OfpActionType() uint16

func (*OfpActionSetField) Parse 

func (a *OfpActionSetField) Parse(packet []byte)

func (*OfpActionSetField) Serialize 

func (a *OfpActionSetField) Serialize() []byte

func (*OfpActionSetField) Size 

func (a *OfpActionSetField) Size() int

type OfpActionSetMplsTtl 

type OfpActionSetMplsTtl struct {
	ActionHeader OfpActionHeader
	MplsTtl      uint8
	Pad          [3]uint8
}

func NewOfpActionSetMplsTtl 

func NewOfpActionSetMplsTtl(ttl uint8) *OfpActionSetMplsTtl

* OfpActionSetMplsTtl

func (*OfpActionSetMplsTtl) OfpActionType 

func (a *OfpActionSetMplsTtl) OfpActionType() uint16

func (*OfpActionSetMplsTtl) Parse 

func (a *OfpActionSetMplsTtl) Parse(packet []byte)

func (*OfpActionSetMplsTtl) Serialize 

func (a *OfpActionSetMplsTtl) Serialize() []byte

func (*OfpActionSetMplsTtl) Size 

func (a *OfpActionSetMplsTtl) Size() int

type OfpActionSetNwTtl 

type OfpActionSetNwTtl struct {
	ActionHeader OfpActionHeader
	NwTtl        uint8
	Pad          [3]uint8
}

func NewOfpActionSetNwTtl 

func NewOfpActionSetNwTtl(ttl uint8) *OfpActionSetNwTtl

* OfpActionSetNwTtl

func (*OfpActionSetNwTtl) OfpActionType 

func (a *OfpActionSetNwTtl) OfpActionType() uint16

func (*OfpActionSetNwTtl) Parse 

func (a *OfpActionSetNwTtl) Parse(packet []byte)

func (*OfpActionSetNwTtl) Serialize 

func (a *OfpActionSetNwTtl) Serialize() []byte

func (*OfpActionSetNwTtl) Size 

func (a *OfpActionSetNwTtl) Size() int

type OfpActionSetQueue 

type OfpActionSetQueue struct {
	ActionHeader OfpActionHeader
	QueueId      uint32
}

func NewOfpActionSetQueue 

func NewOfpActionSetQueue(id uint32) *OfpActionSetQueue

*************************************************** 

OfpActionSetQueue

***************************************************

func (*OfpActionSetQueue) OfpActionType 

func (a *OfpActionSetQueue) OfpActionType() uint16

func (*OfpActionSetQueue) Parse 

func (a *OfpActionSetQueue) Parse(packet []byte)

func (*OfpActionSetQueue) Serialize 

func (a *OfpActionSetQueue) Serialize() []byte

func (*OfpActionSetQueue) Size 

func (a *OfpActionSetQueue) Size() int

type OfpAggregateStats 

type OfpAggregateStats struct {
	PacketCount uint64
	ByteCount   uint64
	FlowCount   uint32
}

func (*OfpAggregateStats) MPType 

func (mp *OfpAggregateStats) MPType() uint16

func (*OfpAggregateStats) Parse 

func (mp *OfpAggregateStats) Parse(packet []byte)

func (*OfpAggregateStats) Serialize 

func (mp *OfpAggregateStats) Serialize() []byte

func (*OfpAggregateStats) Size 

func (mp *OfpAggregateStats) Size() int

type OfpAggregateStatsRequest 

type OfpAggregateStatsRequest struct {
	TableId uint8
	// Pad        [3]uint8
	OutPort  uint32
	OutGroup uint32
	// Pad2       [4]uint8
	Cookie     uint64
	CookieMask uint64
	Match      *OfpMatch
}

func (*OfpAggregateStatsRequest) MPType 

func (mp *OfpAggregateStatsRequest) MPType() uint16

func (*OfpAggregateStatsRequest) Parse 

func (mp *OfpAggregateStatsRequest) Parse(packet []byte)

func (*OfpAggregateStatsRequest) Serialize 

func (mp *OfpAggregateStatsRequest) Serialize() []byte

func (*OfpAggregateStatsRequest) Size 

func (mp *OfpAggregateStatsRequest) Size() int

type OfpAsyncConfig 

type OfpAsyncConfig struct {
	Header          OfpHeader
	PacketInMask    [2]uint32
	PortStatusMask  [2]uint32
	FlowRemovedMask [2]uint32
}

func NewOfpGetAsyncReply 

func NewOfpGetAsyncReply() *OfpAsyncConfig

func NewOfpSetAsync 

func NewOfpSetAsync(
	packetInMask [2]uint32,
	portStatusMask [2]uint32,
	flowRemovedMask [2]uint32) *OfpAsyncConfig

func (*OfpAsyncConfig) Parse 

func (m *OfpAsyncConfig) Parse(packet []byte)

func (*OfpAsyncConfig) Serialize 

func (m *OfpAsyncConfig) Serialize() []byte

func (*OfpAsyncConfig) Size 

func (m *OfpAsyncConfig) Size() int

type OfpBucket 

type OfpBucket struct {
	Length     uint16
	Weight     uint16
	WatchPort  uint32
	WatchGroup uint32
	Pad        [4]uint8
	Actions    []OfpAction
}

func NewOfpBucket 

func NewOfpBucket(weight uint16, watchPort uint32, watchGroup uint32) *OfpBucket

*************************************************** 

OfpBucket

***************************************************

func (*OfpBucket) Append 

func (b *OfpBucket) Append(action OfpAction)

func (*OfpBucket) Parse 

func (b *OfpBucket) Parse(packet []byte)

func (*OfpBucket) Serialize 

func (b *OfpBucket) Serialize() []byte

func (*OfpBucket) Size 

func (b *OfpBucket) Size() int

type OfpBucketCounter 

type OfpBucketCounter struct {
	PacketCount uint64
	ByteCount   uint64
}

func (*OfpBucketCounter) Parse 

func (bc *OfpBucketCounter) Parse(packet []byte)

func (*OfpBucketCounter) Serialize 

func (bc *OfpBucketCounter) Serialize() []byte

func (*OfpBucketCounter) Size 

func (bc *OfpBucketCounter) Size() int

type OfpDescStats 

type OfpDescStats struct {
	MfrDesc   []uint8
	HwDesc    []uint8
	SwDesc    []uint8
	SerialNum []uint8
	DpDesc    []uint8
}

func (*OfpDescStats) MPType 

func (mp *OfpDescStats) MPType() uint16

func (*OfpDescStats) Parse 

func (mp *OfpDescStats) Parse(packet []byte)

func (*OfpDescStats) Serialize 

func (mp *OfpDescStats) Serialize() []byte

func (*OfpDescStats) Size 

func (mp *OfpDescStats) Size() int

type OfpErrorExperimenterMsg 

type OfpErrorExperimenterMsg struct {
	Header       OfpHeader
	Type         uint16
	ExpType      uint16
	Experimenter uint32
	Data         []uint8
}

type OfpErrorMsg 

type OfpErrorMsg struct {
	Header OfpHeader
	Type   uint16
	Code   uint16
	Data   []uint8
}

func NewOfpErrorMsg 

func NewOfpErrorMsg() *OfpErrorMsg

*************************************************** 

OfpErrorMsg

***************************************************

func (*OfpErrorMsg) Parse 

func (m *OfpErrorMsg) Parse(packet []byte)

func (*OfpErrorMsg) Serialize 

func (m *OfpErrorMsg) Serialize() []byte

func (*OfpErrorMsg) Size 

func (m *OfpErrorMsg) Size() int

type OfpExperimenterMultipartHeader 

type OfpExperimenterMultipartHeader struct {
	Header       OfpHeader
	Experimenter uint32
	ExpType      uint32
}

type OfpFlowMod 

type OfpFlowMod struct {
	Header      OfpHeader
	Cookie      uint64
	CookieMask  uint64
	TableId     uint8
	Command     uint8
	IdleTimeout uint16
	HardTimeout uint16
	Priority    uint16
	BufferId    uint32
	OutPort     uint32
	OutGroup    uint32
	Flags       uint16
	// Pad          [2]uint8 // 2
	Match        *OfpMatch
	Instructions []OfpInstruction
}

func NewOfpFlowModAdd 

func NewOfpFlowModAdd(
	cookie uint64,
	cookieMask uint64,
	tableId uint8,
	priority uint16,
	flags uint16,
	match *OfpMatch,
	instructions []OfpInstruction,
) *OfpFlowMod

*************************************************** 

OfpFlowMod

***************************************************

func NewOfpFlowModDelete 

func NewOfpFlowModDelete(
	cookie uint64,
	cookieMask uint64,
	tableId uint8,
	priority uint16,
	outPort uint32,
	outGroup uint32,
	flags uint16,
	match *OfpMatch,
) *OfpFlowMod

func NewOfpFlowModModify 

func NewOfpFlowModModify(
	cookie uint64,
	cookieMask uint64,
	tableId uint8,
	priority uint16,
	flags uint16,
	match *OfpMatch,
	instructions []OfpInstruction,
) *OfpFlowMod

func (*OfpFlowMod) AppendInstruction 

func (m *OfpFlowMod) AppendInstruction(i OfpInstruction)

func (*OfpFlowMod) AppendMatchField 

func (m *OfpFlowMod) AppendMatchField(mf OxmField)

func (*OfpFlowMod) Parse 

func (m *OfpFlowMod) Parse(packet []byte)

func (*OfpFlowMod) Serialize 

func (m *OfpFlowMod) Serialize() []byte

func (*OfpFlowMod) Size 

func (m *OfpFlowMod) Size() int

type OfpFlowRemoved 

type OfpFlowRemoved struct {
	Header       OfpHeader
	Cookie       uint64
	Priority     uint16
	Reason       uint8
	TableId      uint8
	DurationSec  uint32
	DurationNSec uint32
	IdleTimeout  uint16
	HardTimeout  uint16
	PacketCount  uint64
	ByteCount    uint64
	Match        *OfpMatch
}

func NewOfpFlowRemoved 

func NewOfpFlowRemoved() *OfpFlowRemoved

*************************************************** 

OfpFlowRemoved

***************************************************

func (*OfpFlowRemoved) Parse 

func (m *OfpFlowRemoved) Parse(packet []byte)

func (*OfpFlowRemoved) Serialize 

func (m *OfpFlowRemoved) Serialize() []byte

func (*OfpFlowRemoved) Size 

func (m *OfpFlowRemoved) Size() int

type OfpFlowStats 

type OfpFlowStats struct {
	Length       uint16
	TableId      uint8
	Pad          uint8
	DurationSec  uint32
	DurationNSec uint32
	Priority     uint16
	IdleTimeout  uint16
	HardTimeout  uint16
	Flags        uint16
	// Pad2         [4]uint8
	Cookie       uint64
	PacketCount  uint64
	ByteCount    uint64
	Match        *OfpMatch
	Instructions []OfpInstruction
}

func (*OfpFlowStats) MPType 

func (mp *OfpFlowStats) MPType() uint16

func (*OfpFlowStats) Parse 

func (mp *OfpFlowStats) Parse(packet []byte)

func (*OfpFlowStats) Serialize 

func (mp *OfpFlowStats) Serialize() []byte

func (*OfpFlowStats) Size 

func (mp *OfpFlowStats) Size() int

type OfpFlowStatsRequest 

type OfpFlowStatsRequest struct {
	TableId uint8
	// Pad        [3]uint8
	OutPort  uint32
	OutGroup uint32
	// Pad2       [4]uint8
	Cookie     uint64
	CookieMask uint64
	Match      *OfpMatch
}

func (*OfpFlowStatsRequest) MPType 

func (m *OfpFlowStatsRequest) MPType() uint16

func (*OfpFlowStatsRequest) Parse 

func (m *OfpFlowStatsRequest) Parse(packet []byte)

func (*OfpFlowStatsRequest) Serialize 

func (m *OfpFlowStatsRequest) Serialize() []byte

func (*OfpFlowStatsRequest) Size 

func (m *OfpFlowStatsRequest) Size() int

type OfpGroupDescStats 

type OfpGroupDescStats struct {
	Length  uint16
	Type    uint8
	Pad     uint8
	GroupId uint32
	Buckets []*OfpBucket
}

func (*OfpGroupDescStats) MPType 

func (mp *OfpGroupDescStats) MPType() uint16

func (*OfpGroupDescStats) Parse 

func (mp *OfpGroupDescStats) Parse(packet []byte)

func (*OfpGroupDescStats) Serialize 

func (mp *OfpGroupDescStats) Serialize() []byte

func (*OfpGroupDescStats) Size 

func (mp *OfpGroupDescStats) Size() int

type OfpGroupFeaturesStats 

type OfpGroupFeaturesStats struct {
	Type         uint32
	Capabilities uint32
	MaxGroups    [4]uint32
	Actions      [4]uint32
}

func (*OfpGroupFeaturesStats) MPType 

func (mp *OfpGroupFeaturesStats) MPType() uint16

func (*OfpGroupFeaturesStats) Parse 

func (mp *OfpGroupFeaturesStats) Parse(packet []byte)

func (*OfpGroupFeaturesStats) Serialize 

func (mp *OfpGroupFeaturesStats) Serialize() []byte

func (*OfpGroupFeaturesStats) Size 

func (mp *OfpGroupFeaturesStats) Size() int

type OfpGroupMod 

type OfpGroupMod struct {
	Header  OfpHeader
	Command uint16
	Type    uint8
	Pad     uint8
	GroupId uint32
	Buckets []*OfpBucket
}

func NewOfpGroupMod 

func NewOfpGroupMod(command uint16, t uint8, id uint32) *OfpGroupMod

*************************************************** 

OfpGroupMod

***************************************************

func (*OfpGroupMod) Append 

func (m *OfpGroupMod) Append(bucket *OfpBucket)

func (*OfpGroupMod) Parse 

func (m *OfpGroupMod) Parse(packet []byte)

func (*OfpGroupMod) Serialize 

func (m *OfpGroupMod) Serialize() []byte

func (*OfpGroupMod) Size 

func (m *OfpGroupMod) Size() int

type OfpGroupStats 

type OfpGroupStats struct {
	Length uint16
	// Pad          [2]uint8
	GroupId  uint32
	RefCount uint32
	// Pad2         [4]uint8
	PacketCount  uint64
	ByteCount    uint64
	DurationSec  uint32
	DurationNSec uint32
	BucketStats  []*OfpBucketCounter
}

func (*OfpGroupStats) MPType 

func (mp *OfpGroupStats) MPType() uint16

func (*OfpGroupStats) Parse 

func (mp *OfpGroupStats) Parse(packet []byte)

func (*OfpGroupStats) Serialize 

func (mp *OfpGroupStats) Serialize() []byte

func (*OfpGroupStats) Size 

func (mp *OfpGroupStats) Size() int

type OfpGroupStatsRequest 

type OfpGroupStatsRequest struct {
	GroupId uint32
	Pad     [4]uint8
}

func (*OfpGroupStatsRequest) MPType 

func (mp *OfpGroupStatsRequest) MPType() uint16

func (*OfpGroupStatsRequest) Parse 

func (mp *OfpGroupStatsRequest) Parse(packet []byte)

func (*OfpGroupStatsRequest) Serialize 

func (mp *OfpGroupStatsRequest) Serialize() []byte

func (*OfpGroupStatsRequest) Size 

func (mp *OfpGroupStatsRequest) Size() int

type OfpHeader 

type OfpHeader struct {
	Version uint8
	Type    uint8
	Length  uint16
	Xid     uint32
}

*

  • OfpHeader

func NewOfpBarrierReply 

func NewOfpBarrierReply() *OfpHeader

func NewOfpBarrierRequest 

func NewOfpBarrierRequest() *OfpHeader

*************************************************** 

BarrierRequest Message

***************************************************

func NewOfpEchoReply 

func NewOfpEchoReply() *OfpHeader

func NewOfpEchoRequest 

func NewOfpEchoRequest() *OfpHeader

*************************************************** 

Echo Message

***************************************************

func NewOfpFeaturesRequest 

func NewOfpFeaturesRequest() *OfpHeader

*************************************************** 

OfpFeaturesRequest

***************************************************

func NewOfpGetAsyncRequest 

func NewOfpGetAsyncRequest() *OfpHeader

*************************************************** 

OfpAsyncConfig

***************************************************

func NewOfpGetConfig 

func NewOfpGetConfig() *OfpHeader

*************************************************** 

OfpSwitchConfig

***************************************************

func NewOfpHeader 

func NewOfpHeader(t uint8) OfpHeader

/ create OfpHeader instance.

func (*OfpHeader) Parse 

func (h *OfpHeader) Parse(packet []byte)

/ Parse packet data and set value to OfpHeader instance.

func (*OfpHeader) Serialize 

func (h *OfpHeader) Serialize() []byte

/ Serialize OfpHeader and return it as slice of byte.

func (*OfpHeader) Size 

func (h *OfpHeader) Size() int

/ Return OfpHeader's size.

type OfpHello 

type OfpHello struct {
	Header   OfpHeader
	Elements []OfpHelloElemHeader
}

*

  • Hello Message

func NewOfpHello 

func NewOfpHello() *OfpHello

*************************************************** 

OfpHello

***************************************************

func (*OfpHello) Parse 

func (m *OfpHello) Parse(packet []byte)

func (*OfpHello) Serialize 

func (m *OfpHello) Serialize() []byte

/ /

func (*OfpHello) Size 

func (m *OfpHello) Size() int

type OfpHelloElemHeader 

type OfpHelloElemHeader struct {
	Type   uint16
	Length uint16
}

func NewOfpHelloElemHeader 

func NewOfpHelloElemHeader() *OfpHelloElemHeader

*************************************************** 

OfpHelloElemHeader

***************************************************

func (*OfpHelloElemHeader) Parse 

func (h *OfpHelloElemHeader) Parse(packet []byte)

func (*OfpHelloElemHeader) Serialize 

func (h *OfpHelloElemHeader) Serialize() []byte

func (*OfpHelloElemHeader) Size 

func (h *OfpHelloElemHeader) Size() int

type OfpHelloElemVersionBitmap 

type OfpHelloElemVersionBitmap struct {
	Type    uint16
	Length  uint16
	Bitmaps []uint32
}

type OfpInstruction 

type OfpInstruction interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
	InstructionType() uint16
}

type OfpInstructionActions 

type OfpInstructionActions struct {
	Header  OfpInstructionHeader
	Pad     [4]uint8
	Actions []OfpAction
}

func NewOfpInstructionActions 

func NewOfpInstructionActions(
	t uint16) *OfpInstructionActions

* OfpInstructionActions

func (*OfpInstructionActions) Append 

func (i *OfpInstructionActions) Append(a OfpAction)

func (*OfpInstructionActions) InstructionType 

func (i *OfpInstructionActions) InstructionType() uint16

func (*OfpInstructionActions) Parse 

func (i *OfpInstructionActions) Parse(packet []byte)

func (*OfpInstructionActions) Serialize 

func (i *OfpInstructionActions) Serialize() []byte

func (*OfpInstructionActions) Size 

func (i *OfpInstructionActions) Size() int

type OfpInstructionExperimenter 

type OfpInstructionExperimenter struct {
	Header       OfpInstructionHeader
	Experimenter uint32
}

func NewOfpInstructionExperimenter 

func NewOfpInstructionExperimenter(
	experimenter uint32) *OfpInstructionExperimenter

* OfpInstructionExperimenter

func (*OfpInstructionExperimenter) InstructionType 

func (i *OfpInstructionExperimenter) InstructionType() uint16

func (*OfpInstructionExperimenter) Parse 

func (i *OfpInstructionExperimenter) Parse(packet []byte)

func (*OfpInstructionExperimenter) Serialize 

func (i *OfpInstructionExperimenter) Serialize() []byte

func (*OfpInstructionExperimenter) Size 

func (i *OfpInstructionExperimenter) Size() int

type OfpInstructionGotoTable 

type OfpInstructionGotoTable struct {
	Header  OfpInstructionHeader
	TableId uint8
	Pad     [3]uint8
}

func NewOfpInstructionGotoTable 

func NewOfpInstructionGotoTable(id uint8) *OfpInstructionGotoTable

* OfpInstructionGotoTable

func (*OfpInstructionGotoTable) InstructionType 

func (i *OfpInstructionGotoTable) InstructionType() uint16

func (*OfpInstructionGotoTable) Parse 

func (i *OfpInstructionGotoTable) Parse(packet []byte)

func (*OfpInstructionGotoTable) Serialize 

func (i *OfpInstructionGotoTable) Serialize() []byte

func (*OfpInstructionGotoTable) Size 

func (i *OfpInstructionGotoTable) Size() int

type OfpInstructionHeader 

type OfpInstructionHeader struct {
	Type   uint16
	Length uint16
}

func NewOfpInstructionHeader 

func NewOfpInstructionHeader(t uint16) OfpInstructionHeader

*************************************************** 

OfpInstruction

***************************************************

func (*OfpInstructionHeader) Parse 

func (h *OfpInstructionHeader) Parse(packet []byte)

func (*OfpInstructionHeader) Serialize 

func (h *OfpInstructionHeader) Serialize() []byte

func (OfpInstructionHeader) Size 

func (i OfpInstructionHeader) Size() int

type OfpInstructionId 

type OfpInstructionId struct {
	Type   uint16
	Length uint16
}

func NewOfpInstructionId 

func NewOfpInstructionId(t uint16, length uint16) *OfpInstructionId

*************************************************** 

OfpInstructionId

***************************************************

func (*OfpInstructionId) Parse 

func (i *OfpInstructionId) Parse(packet []byte)

func (*OfpInstructionId) Serialize 

func (i *OfpInstructionId) Serialize() []byte

func (*OfpInstructionId) Size 

func (p *OfpInstructionId) Size() int

type OfpInstructionMeter 

type OfpInstructionMeter struct {
	Header  OfpInstructionHeader
	MeterId uint32
}

func NewOfpInstructionMeter 

func NewOfpInstructionMeter(
	meterId uint32) *OfpInstructionMeter

* OfpInstructionMeter

func (*OfpInstructionMeter) InstructionType 

func (i *OfpInstructionMeter) InstructionType() uint16

func (*OfpInstructionMeter) Parse 

func (i *OfpInstructionMeter) Parse(packet []byte)

func (*OfpInstructionMeter) Serialize 

func (i *OfpInstructionMeter) Serialize() []byte

func (*OfpInstructionMeter) Size 

func (i *OfpInstructionMeter) Size() int

type OfpInstructionWriteMetadata 

type OfpInstructionWriteMetadata struct {
	Header       OfpInstructionHeader
	Pad          [4]uint8
	Metadata     uint64
	MetadataMask uint64
}

func NewOfpInstructionWriteMetadata 

func NewOfpInstructionWriteMetadata(metadata uint64, mask uint64) *OfpInstructionWriteMetadata

* OfpInstructionWriteMetadata

func (*OfpInstructionWriteMetadata) InstructionType 

func (i *OfpInstructionWriteMetadata) InstructionType() uint16

func (*OfpInstructionWriteMetadata) Parse 

func (i *OfpInstructionWriteMetadata) Parse(packet []byte)

func (*OfpInstructionWriteMetadata) Serialize 

func (i *OfpInstructionWriteMetadata) Serialize() []byte

func (*OfpInstructionWriteMetadata) Size 

func (i *OfpInstructionWriteMetadata) Size() int

type OfpMatch 

type OfpMatch struct {
	Type      uint16
	Length    uint16
	OxmFields []OxmField
}

func NewOfpMatch 

func NewOfpMatch() *OfpMatch

func (*OfpMatch) Append 

func (m *OfpMatch) Append(f OxmField)

func (*OfpMatch) Parse 

func (m *OfpMatch) Parse(packet []byte)

func (*OfpMatch) Serialize 

func (m *OfpMatch) Serialize() []byte

func (*OfpMatch) Size 

func (m *OfpMatch) Size() int

type OfpMeterBand 

type OfpMeterBand interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
	MeterBandType() uint16
}

func ParseMeter 

func ParseMeter(packet []byte) (mb OfpMeterBand)

* MeterBand Parser

type OfpMeterBandDrop 

type OfpMeterBandDrop struct {
	Header OfpMeterBandHeader
}

func NewOfpMeterBandDrop 

func NewOfpMeterBandDrop(rate uint32, burstSize uint32) *OfpMeterBandDrop

*************************************************** 

OfpMeterBandDrop

***************************************************

func (*OfpMeterBandDrop) MeterBandType 

func (m *OfpMeterBandDrop) MeterBandType() uint16

func (*OfpMeterBandDrop) Parse 

func (m *OfpMeterBandDrop) Parse(packet []byte)

func (*OfpMeterBandDrop) Serialize 

func (m *OfpMeterBandDrop) Serialize() []byte

func (*OfpMeterBandDrop) Size 

func (m *OfpMeterBandDrop) Size() int

type OfpMeterBandDscpRemark 

type OfpMeterBandDscpRemark struct {
	Header    OfpMeterBandHeader
	PrecLevel uint8
}

func NewOfpMeterBandDscpRemark 

func NewOfpMeterBandDscpRemark(rate uint32, burstSize uint32, precLevel uint8) *OfpMeterBandDscpRemark

*************************************************** 

OfpMeterBandDscpRemark

***************************************************

func (*OfpMeterBandDscpRemark) MeterBandType 

func (m *OfpMeterBandDscpRemark) MeterBandType() uint16

func (*OfpMeterBandDscpRemark) Parse 

func (m *OfpMeterBandDscpRemark) Parse(packet []byte)

func (*OfpMeterBandDscpRemark) Serialize 

func (m *OfpMeterBandDscpRemark) Serialize() []byte

func (*OfpMeterBandDscpRemark) Size 

func (m *OfpMeterBandDscpRemark) Size() int

type OfpMeterBandExperimenter 

type OfpMeterBandExperimenter struct {
	Header       OfpMeterBandHeader
	Experimenter uint32
}

func NewOfpMeterBandExperimenter 

func NewOfpMeterBandExperimenter(rate uint32, burstSize uint32, experimenter uint32) *OfpMeterBandExperimenter

*************************************************** 

OfpMeterBandExperimenter

***************************************************

func (*OfpMeterBandExperimenter) MeterBandType 

func (m *OfpMeterBandExperimenter) MeterBandType() uint16

func (*OfpMeterBandExperimenter) Parse 

func (m *OfpMeterBandExperimenter) Parse(packet []byte)

func (*OfpMeterBandExperimenter) Serialize 

func (m *OfpMeterBandExperimenter) Serialize() []byte

func (*OfpMeterBandExperimenter) Size 

func (m *OfpMeterBandExperimenter) Size() int

type OfpMeterBandHeader 

type OfpMeterBandHeader struct {
	Type      uint16
	Length    uint16
	Rate      uint32
	BurstSize uint32
}

func NewOfpMeterBandHeader 

func NewOfpMeterBandHeader(t uint16, rate uint32, burstSize uint32) OfpMeterBandHeader

*************************************************** 

OfpMeterBandHeader

***************************************************

func (*OfpMeterBandHeader) Parse 

func (m *OfpMeterBandHeader) Parse(packet []byte)

func (*OfpMeterBandHeader) Serialize 

func (m *OfpMeterBandHeader) Serialize() []byte

func (*OfpMeterBandHeader) Size 

func (m *OfpMeterBandHeader) Size() int

type OfpMeterBandStats 

type OfpMeterBandStats struct {
	PacketBandCount uint64
	ByteBandCount   uint64
}

func (*OfpMeterBandStats) Parse 

func (mb *OfpMeterBandStats) Parse(packet []byte)

func (*OfpMeterBandStats) Serialize 

func (mb *OfpMeterBandStats) Serialize() []byte

func (*OfpMeterBandStats) Size 

func (mb *OfpMeterBandStats) Size() int

type OfpMeterConfig 

type OfpMeterConfig struct {
	Length  uint16
	Flags   uint16
	MeterId uint32
	Bands   []OfpMeterBand
}

func (*OfpMeterConfig) MPType 

func (mp *OfpMeterConfig) MPType() uint16

func (*OfpMeterConfig) Parse 

func (mp *OfpMeterConfig) Parse(packet []byte)

func (*OfpMeterConfig) Serialize 

func (mp *OfpMeterConfig) Serialize() []byte

func (*OfpMeterConfig) Size 

func (mp *OfpMeterConfig) Size() int

type OfpMeterFeatures 

type OfpMeterFeatures struct {
	MaxMeter     uint32
	BandTypes    uint32
	Capabilities uint32
	MaxBands     uint8
	MaxColor     uint8
	Pad          [2]uint8
}

func (*OfpMeterFeatures) MPType 

func (mp *OfpMeterFeatures) MPType() uint16

func (*OfpMeterFeatures) Parse 

func (mp *OfpMeterFeatures) Parse(packet []byte)

func (*OfpMeterFeatures) Serialize 

func (mp *OfpMeterFeatures) Serialize() []byte

func (*OfpMeterFeatures) Size 

func (mp *OfpMeterFeatures) Size() int

type OfpMeterMod 

type OfpMeterMod struct {
	Header  OfpHeader
	Command uint16
	Flags   uint16
	MeterId uint32
	Bands   []OfpMeterBand
}

func NewOfpMeterMod 

func NewOfpMeterMod(command uint16, flags uint16, id uint32) *OfpMeterMod

*************************************************** 

OfpMeterMod

***************************************************

func (*OfpMeterMod) AppendMeterBand 

func (m *OfpMeterMod) AppendMeterBand(mb OfpMeterBand)

func (*OfpMeterMod) Parse 

func (m *OfpMeterMod) Parse(packet []byte)

func (*OfpMeterMod) Serialize 

func (m *OfpMeterMod) Serialize() []byte

func (*OfpMeterMod) Size 

func (m *OfpMeterMod) Size() int

type OfpMeterMultipartRequest 

type OfpMeterMultipartRequest struct {
	MeterId uint32
}

func (*OfpMeterMultipartRequest) MPType 

func (mp *OfpMeterMultipartRequest) MPType() uint16

func (*OfpMeterMultipartRequest) Parse 

func (mp *OfpMeterMultipartRequest) Parse(packet []byte)

func (*OfpMeterMultipartRequest) Serialize 

func (mp *OfpMeterMultipartRequest) Serialize() []byte

func (*OfpMeterMultipartRequest) Size 

func (mp *OfpMeterMultipartRequest) Size() int

type OfpMeterStats 

type OfpMeterStats struct {
	MeterId uint32
	Length  uint16
	// Pad           [6]uint8
	FlowCount     uint32
	PacketInCount uint64
	ByteInCount   uint64
	DurationSec   uint32
	DurationNSec  uint32
	BandStats     []*OfpMeterBandStats
}

func (*OfpMeterStats) MPType 

func (mp *OfpMeterStats) MPType() uint16

func (*OfpMeterStats) Parse 

func (mp *OfpMeterStats) Parse(packet []byte)

func (*OfpMeterStats) Serialize 

func (mp *OfpMeterStats) Serialize() []byte

func (*OfpMeterStats) Size 

func (mp *OfpMeterStats) Size() int

type OfpMultipartBody 

type OfpMultipartBody interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
	MPType() uint16
}

type OfpMultipartReply 

type OfpMultipartReply struct {
	Header OfpHeader
	Type   uint16
	Flags  uint16
	// Pad    [4]uint8
	Body []OfpMultipartBody
}

func NewOfpMultipartReply 

func NewOfpMultipartReply() *OfpMultipartReply

*************************************************** 

OfpMultipartReply

***************************************************

func (*OfpMultipartReply) Append 

func (m *OfpMultipartReply) Append(mp OfpMultipartBody)

func (*OfpMultipartReply) Parse 

func (m *OfpMultipartReply) Parse(packet []byte)

func (*OfpMultipartReply) Serialize 

func (m *OfpMultipartReply) Serialize() []byte

func (*OfpMultipartReply) Size 

func (m *OfpMultipartReply) Size() int

type OfpMultipartRequest 

type OfpMultipartRequest struct {
	Header OfpHeader
	Type   uint16
	Flags  uint16
	// Pad    [4]uint8
	Body OfpMultipartBody
}

func NewOfpAggregateStatsRequest 

func NewOfpAggregateStatsRequest(
	flags uint16,
	tableId uint8,
	outPort uint32,
	outGroup uint32,
	cookie uint64,
	cookieMask uint64,
	match *OfpMatch) *OfpMultipartRequest

func NewOfpDescStatsRequest 

func NewOfpDescStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpExperimenterStatsRequest 

func NewOfpExperimenterStatsRequest() *OfpMultipartRequest

func NewOfpFlowStatsRequest 

func NewOfpFlowStatsRequest(
	flags uint16,
	tableId uint8,
	outPort uint32,
	outGroup uint32,
	cookie uint64,
	cookieMask uint64,
	match *OfpMatch) *OfpMultipartRequest

func NewOfpGroupDescStatsRequest 

func NewOfpGroupDescStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpGroupFeaturesStatsRequest 

func NewOfpGroupFeaturesStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpGroupStatsRequest 

func NewOfpGroupStatsRequest(groupId uint32, flags uint16) *OfpMultipartRequest

func NewOfpMeterConfigStatsRequest 

func NewOfpMeterConfigStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpMeterFeaturesStatsRequest 

func NewOfpMeterFeaturesStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpMeterStatsRequest 

func NewOfpMeterStatsRequest(meterId uint32, flags uint16) *OfpMultipartRequest

func NewOfpMultipartRequest 

func NewOfpMultipartRequest(t uint16, flags uint16) *OfpMultipartRequest

func NewOfpPortDescStatsRequest 

func NewOfpPortDescStatsRequest(flags uint16) *OfpMultipartRequest

func NewOfpPortStatsRequest 

func NewOfpPortStatsRequest(portNo uint32, flags uint16) *OfpMultipartRequest

func NewOfpQueueStatsRequest 

func NewOfpQueueStatsRequest(portNo uint32, queueId uint32, flags uint16) *OfpMultipartRequest

func NewOfpTableFeaturesStatsRequest 

func NewOfpTableFeaturesStatsRequest(flags uint16, body *OfpTableFeatures) *OfpMultipartRequest

func NewOfpTableStatsRequest 

func NewOfpTableStatsRequest(flags uint16) *OfpMultipartRequest

func (*OfpMultipartRequest) Parse 

func (m *OfpMultipartRequest) Parse(packet []byte)

func (*OfpMultipartRequest) Serialize 

func (m *OfpMultipartRequest) Serialize() []byte

func (*OfpMultipartRequest) Size 

func (m *OfpMultipartRequest) Size() int

type OfpOxmExperimenterHeader 

type OfpOxmExperimenterHeader struct {
	OxmHeader    uint32
	Experimenter uint32
}

type OfpPacketIn 

type OfpPacketIn struct {
	Header   OfpHeader
	BufferId uint32
	TotalLen uint16
	Reason   uint8
	TableId  uint8
	Cookie   uint64
	Match    *OfpMatch
	Pad      [2]uint8
	Data     []uint8
}

func NewOfpPacketIn 

func NewOfpPacketIn() *OfpPacketIn

*************************************************** 

OfpPacketIn

***************************************************

func (*OfpPacketIn) Parse 

func (m *OfpPacketIn) Parse(packet []byte)
From openflow 1.3 spec

https://www.opennetworking.org/software-defined-standards/specifications/ -> openflow-spec-v1.3.0.pdf

//Packet received on port (datapath -> controller). 

struct ofp_packet_in {
	struct ofp_header header;
	uint32_t buffer_id; // ID assigned by datapath.
	uint16_t total_len; // Full length of frame.
	uint8_t reason; // Reason packet is being sent (one of OFPR_*)
	uint8_t table_id; // ID of the table that was looked up
	uint64_t cookie; // Cookie of the flow entry that was looked up.
	struct ofp_match match; // Packet metadata. Variable size.
	// Followed by:
	* - Exactly 2 all-zero padding bytes, then
	* - An Ethernet frame whose length is inferred from header.length.
	* The padding bytes preceding the Ethernet frame ensure that the IP
	* header (if any) following the Ethernet header is 32-bit aligned.

	uint8_t pad[2]; // Align to 64 bit + 16 bit
	uint8_t data[0]; // Ethernet frame
};

func (*OfpPacketIn) Serialize 

func (m *OfpPacketIn) Serialize() []byte

func (*OfpPacketIn) Size 

func (m *OfpPacketIn) Size() int

type OfpPacketOut 

type OfpPacketOut struct {
	Header    OfpHeader
	BufferId  uint32
	InPort    uint32
	ActionLen uint16
	Pad       [6]uint8
	Actions   []OfpAction
	Data      []byte
}

func NewOfpPacketOut 

func NewOfpPacketOut(
	bufferId uint32,
	inPort uint32,
	actions []OfpAction,
	data []byte) *OfpPacketOut

*************************************************** 

OfpPacketOut

***************************************************

func (*OfpPacketOut) AppendAction 

func (m *OfpPacketOut) AppendAction(a OfpAction)

func (*OfpPacketOut) Parse 

func (m *OfpPacketOut) Parse(packet []byte)

func (*OfpPacketOut) Serialize 

func (m *OfpPacketOut) Serialize() []byte

func (*OfpPacketOut) Size 

func (m *OfpPacketOut) Size() int

type OfpPacketQueue 

type OfpPacketQueue struct {
	QueueId uint32
	Port    uint32
	Length  uint16
	// Pad        [6]uint8
	Properties []OfpQueueProp
}

func (*OfpPacketQueue) Parse 

func (q *OfpPacketQueue) Parse(packet []byte)

func (*OfpPacketQueue) Size 

func (q *OfpPacketQueue) Size() int

type OfpPort 

type OfpPort struct {
	PortNo uint32
	// Pad    [4]uint8
	HwAddr net.HardwareAddr
	// Pad2   [2]uint8
	Name       []byte // 16
	Config     uint32
	State      uint32
	Curr       uint32
	Advertised uint32
	Supported  uint32
	Peer       uint32
	CurrSpeed  uint32
	MaxSpeed   uint32
}

func (*OfpPort) MPType 

func (p *OfpPort) MPType() uint16

func (*OfpPort) Parse 

func (p *OfpPort) Parse(packet []byte)

func (*OfpPort) Serialize 

func (p *OfpPort) Serialize() []byte

func (*OfpPort) Size 

func (p *OfpPort) Size() int

type OfpPortMod 

type OfpPortMod struct {
	Header OfpHeader
	PortNo uint32
	// Pad       [4]uint8
	HwAddr net.HardwareAddr // 6
	// Pad2      [2]uint8
	Config    uint32
	Mask      uint32
	Advertise uint32
}

func NewOfpPortMod 

func NewOfpPortMod(
	portNo uint32,
	hwAddr string,
	config uint32,
	mask uint32,
	advertise uint32) (*OfpPortMod, error)

*************************************************** 

OfpPortMod

***************************************************

func (*OfpPortMod) Parse 

func (m *OfpPortMod) Parse(packet []byte)

func (*OfpPortMod) Serialize 

func (m *OfpPortMod) Serialize() []byte

func (*OfpPortMod) Size 

func (m *OfpPortMod) Size() int

type OfpPortStats 

type OfpPortStats struct {
	PortNo uint32
	// Pad          [4]uint8
	RxPackets    uint64
	TxPackets    uint64
	RxBytes      uint64
	TxBytes      uint64
	RxDropped    uint64
	TxDropped    uint64
	RxErrors     uint64
	TxErrors     uint64
	RxFrameErr   uint64
	RxOverErr    uint64
	RxCrcErr     uint64
	Collisions   uint64
	DurationSec  uint32
	DurationNSec uint32
}

func (*OfpPortStats) MPType 

func (mp *OfpPortStats) MPType() uint16

func (*OfpPortStats) Parse 

func (mp *OfpPortStats) Parse(packet []byte)

func (*OfpPortStats) Serialize 

func (mp *OfpPortStats) Serialize() []byte

func (*OfpPortStats) Size 

func (mp *OfpPortStats) Size() int

type OfpPortStatsRequest 

type OfpPortStatsRequest struct {
	PortNo uint32
}

func (*OfpPortStatsRequest) MPType 

func (mp *OfpPortStatsRequest) MPType() uint16

func (*OfpPortStatsRequest) Parse 

func (mp *OfpPortStatsRequest) Parse(packet []byte)

func (*OfpPortStatsRequest) Serialize 

func (mp *OfpPortStatsRequest) Serialize() []byte

func (*OfpPortStatsRequest) Size 

func (mp *OfpPortStatsRequest) Size() int

type OfpPortStatus 

type OfpPortStatus struct {
	Header OfpHeader
	Reason uint8
	// Pad    [7]uint8
	Desc *OfpPort
}

func NewOfpPortStatus 

func NewOfpPortStatus() *OfpPortStatus

func (*OfpPortStatus) Parse 

func (m *OfpPortStatus) Parse(packet []byte)

func (*OfpPortStatus) Serialize 

func (m *OfpPortStatus) Serialize() []byte

func (*OfpPortStatus) Size 

func (m *OfpPortStatus) Size() int

type OfpQueueGetConfigReply 

type OfpQueueGetConfigReply struct {
	Header OfpHeader
	Port   uint32
	// Pad    [4]uint8
	Queue []*OfpPacketQueue
}

func NewOfpQueueGetConfigReply 

func NewOfpQueueGetConfigReply() *OfpQueueGetConfigReply

*************************************************** 

OfpQueueGetConfigReply

***************************************************

func (*OfpQueueGetConfigReply) Parse 

func (m *OfpQueueGetConfigReply) Parse(packet []byte)

func (*OfpQueueGetConfigReply) Serialize 

func (m *OfpQueueGetConfigReply) Serialize() []byte

func (*OfpQueueGetConfigReply) Size 

func (m *OfpQueueGetConfigReply) Size() int

type OfpQueueGetConfigRequest 

type OfpQueueGetConfigRequest struct {
	Header OfpHeader
	Port   uint32
}

func NewOfpQueueGetConfigRequest 

func NewOfpQueueGetConfigRequest(port uint32) *OfpQueueGetConfigRequest

*************************************************** 

OfpQueueGetConfigRequest

***************************************************

func (*OfpQueueGetConfigRequest) Parse 

func (m *OfpQueueGetConfigRequest) Parse(packet []byte)

func (*OfpQueueGetConfigRequest) Serialize 

func (m *OfpQueueGetConfigRequest) Serialize() []byte

func (*OfpQueueGetConfigRequest) Size 

func (m *OfpQueueGetConfigRequest) Size() int

type OfpQueueProp 

type OfpQueueProp interface {
	Parse(packet []byte)
	Size() int
	Property() uint16
}

type OfpQueuePropExperimenter 

type OfpQueuePropExperimenter struct {
	PropHeader   OfpQueuePropHeader
	Experimenter uint32
	// Pad          [4]uint8
	Data []uint8
}

func (*OfpQueuePropExperimenter) Parse 

func (p *OfpQueuePropExperimenter) Parse(packet []byte)

func (*OfpQueuePropExperimenter) Property 

func (p *OfpQueuePropExperimenter) Property() uint16

func (*OfpQueuePropExperimenter) Size 

func (p *OfpQueuePropExperimenter) Size() int

type OfpQueuePropHeader 

type OfpQueuePropHeader struct {
	Property uint16
	Length   uint16
}

func (OfpQueuePropHeader) Parse 

func (h OfpQueuePropHeader) Parse(packet []byte)

func (OfpQueuePropHeader) Size 

func (h OfpQueuePropHeader) Size() int

type OfpQueuePropMaxRate 

type OfpQueuePropMaxRate struct {
	PropHeader OfpQueuePropHeader
	Rate       uint16
}

func (*OfpQueuePropMaxRate) Parse 

func (p *OfpQueuePropMaxRate) Parse(packet []byte)

func (*OfpQueuePropMaxRate) Property 

func (p *OfpQueuePropMaxRate) Property() uint16

func (*OfpQueuePropMaxRate) Size 

func (p *OfpQueuePropMaxRate) Size() int

type OfpQueuePropMinRate 

type OfpQueuePropMinRate struct {
	PropHeader OfpQueuePropHeader
	Rate       uint16
}

func (*OfpQueuePropMinRate) Parse 

func (p *OfpQueuePropMinRate) Parse(packet []byte)

func (*OfpQueuePropMinRate) Property 

func (p *OfpQueuePropMinRate) Property() uint16

func (*OfpQueuePropMinRate) Size 

func (p *OfpQueuePropMinRate) Size() int

type OfpQueueStats 

type OfpQueueStats struct {
	PortNo       uint32
	QueueId      uint32
	TxBytes      uint64
	TxPackets    uint64
	TxErrors     uint64
	DurationSec  uint32
	DurationNSec uint32
}

func (*OfpQueueStats) MPType 

func (mp *OfpQueueStats) MPType() uint16

func (*OfpQueueStats) Parse 

func (mp *OfpQueueStats) Parse(packet []byte)

func (*OfpQueueStats) Serialize 

func (mp *OfpQueueStats) Serialize() []byte

func (*OfpQueueStats) Size 

func (mp *OfpQueueStats) Size() int

type OfpQueueStatsRequest 

type OfpQueueStatsRequest struct {
	PortNo  uint32
	QueueId uint32
}

func (*OfpQueueStatsRequest) MPType 

func (mp *OfpQueueStatsRequest) MPType() uint16

func (*OfpQueueStatsRequest) Parse 

func (mp *OfpQueueStatsRequest) Parse(packet []byte)

func (*OfpQueueStatsRequest) Serialize 

func (mp *OfpQueueStatsRequest) Serialize() []byte

func (*OfpQueueStatsRequest) Size 

func (mp *OfpQueueStatsRequest) Size() int

type OfpRole 

type OfpRole struct {
	Header OfpHeader
	Role   uint32
	// Pad          [4]uint8
	GenerationId uint64
}

func NewOfpRoleReply 

func NewOfpRoleReply() *OfpRole

func NewOfpRoleRequest 

func NewOfpRoleRequest(role uint32, generationId uint64) *OfpRole

*************************************************** 

OfpRoleRequest

***************************************************

func (*OfpRole) Parse 

func (m *OfpRole) Parse(packet []byte)

func (*OfpRole) Serialize 

func (m *OfpRole) Serialize() []byte

func (*OfpRole) Size 

func (m *OfpRole) Size() int

type OfpSwitchConfig 

type OfpSwitchConfig struct {
	Header      OfpHeader
	Flags       uint16
	MissSendLen uint16
}

func NewOfpSetConfig 

func NewOfpSetConfig(flags uint16, missSendLen uint16) *OfpSwitchConfig

func (*OfpSwitchConfig) Parse 

func (m *OfpSwitchConfig) Parse(packet []byte)

func (*OfpSwitchConfig) Serialize 

func (m *OfpSwitchConfig) Serialize() []byte

func (*OfpSwitchConfig) Size 

func (m *OfpSwitchConfig) Size() int

type OfpSwitchFeatures 

type OfpSwitchFeatures struct {
	Header       OfpHeader
	DatapathId   uint64
	NBuffers     uint32
	NTables      uint8
	AuxiliaryId  uint8
	Pad          [2]uint8
	Capabilities uint32
	Reserved     uint32
}

func NewOfpFeaturesReply 

func NewOfpFeaturesReply() *OfpSwitchFeatures

*************************************************** 

OfpSwitchFeatures

***************************************************

func (*OfpSwitchFeatures) Parse 

func (m *OfpSwitchFeatures) Parse(packet []byte)

func (*OfpSwitchFeatures) Serialize 

func (m *OfpSwitchFeatures) Serialize() []byte

func (*OfpSwitchFeatures) Size 

func (m *OfpSwitchFeatures) Size() int

type OfpTableFeatureProp 

type OfpTableFeatureProp interface {
	Serialize() []byte
	Parse(packet []byte)
	Size() int
	Property() uint16
}

type OfpTableFeaturePropActions 

type OfpTableFeaturePropActions struct {
	PropHeader OfpTableFeaturePropHeader
	ActionIds  []OfpActionHeader
}

func NewOfpTableFeaturePropActions 

func NewOfpTableFeaturePropActions(t uint16, ids []OfpActionHeader) *OfpTableFeaturePropActions

*************************************************** 

OfpTableFeaturePropActions

***************************************************

func (*OfpTableFeaturePropActions) Parse 

func (p *OfpTableFeaturePropActions) Parse(packet []byte)

func (*OfpTableFeaturePropActions) Property 

func (p *OfpTableFeaturePropActions) Property() uint16

func (*OfpTableFeaturePropActions) Serialize 

func (p *OfpTableFeaturePropActions) Serialize() []byte

func (*OfpTableFeaturePropActions) Size 

func (p *OfpTableFeaturePropActions) Size() int

type OfpTableFeaturePropExperimenter 

type OfpTableFeaturePropExperimenter struct {
	PropHeader       OfpTableFeaturePropHeader
	Experimenter     uint32
	ExpType          uint32
	ExperimenterData []uint32
}

func NewOfpTableFeaturePropExperimenter 

func NewOfpTableFeaturePropExperimenter(
	t uint16,
	experimenter uint32,
	expType uint32,
	data []uint32) *OfpTableFeaturePropExperimenter

*************************************************** 

OfpTableFeaturePropExperimenter

***************************************************

func (*OfpTableFeaturePropExperimenter) Parse 

func (p *OfpTableFeaturePropExperimenter) Parse(packet []byte)

func (*OfpTableFeaturePropExperimenter) Property 

func (p *OfpTableFeaturePropExperimenter) Property() uint16

func (*OfpTableFeaturePropExperimenter) Serialize 

func (p *OfpTableFeaturePropExperimenter) Serialize() []byte

func (*OfpTableFeaturePropExperimenter) Size 

func (p *OfpTableFeaturePropExperimenter) Size() int

type OfpTableFeaturePropHeader 

type OfpTableFeaturePropHeader struct {
	Type   uint16
	Length uint16
}

func NewOfpTableFeaturePropHeader 

func NewOfpTableFeaturePropHeader(t uint16, length uint16) OfpTableFeaturePropHeader

*************************************************** 

OfpTableFeaturePropHeader

***************************************************

func (*OfpTableFeaturePropHeader) Parse 

func (p *OfpTableFeaturePropHeader) Parse(packet []byte)

func (*OfpTableFeaturePropHeader) Serialize 

func (p *OfpTableFeaturePropHeader) Serialize() []byte

func (*OfpTableFeaturePropHeader) Size 

func (p *OfpTableFeaturePropHeader) Size() int

type OfpTableFeaturePropInstructions 

type OfpTableFeaturePropInstructions struct {
	PropHeader     OfpTableFeaturePropHeader
	InstructionIds []*OfpInstructionId
}

func NewOfpTableFeaturePropInstructions 

func NewOfpTableFeaturePropInstructions(
	t uint16,
	ids []*OfpInstructionId) *OfpTableFeaturePropInstructions

*************************************************** 

OfpTableFeaturePropInstructions

***************************************************

func (*OfpTableFeaturePropInstructions) Parse 

func (p *OfpTableFeaturePropInstructions) Parse(packet []byte)

func (*OfpTableFeaturePropInstructions) Property 

func (p *OfpTableFeaturePropInstructions) Property() uint16

func (*OfpTableFeaturePropInstructions) Serialize 

func (p *OfpTableFeaturePropInstructions) Serialize() []byte

func (*OfpTableFeaturePropInstructions) Size 

func (p *OfpTableFeaturePropInstructions) Size() int

type OfpTableFeaturePropNextTables 

type OfpTableFeaturePropNextTables struct {
	PropHeader   OfpTableFeaturePropHeader
	NextTableIds []uint8
}

func NewOfpTableFeaturePropNextTables 

func NewOfpTableFeaturePropNextTables(t uint16, ids []uint8) *OfpTableFeaturePropNextTables

*************************************************** 

OfpTableFeaturePropNextTables

***************************************************

func (*OfpTableFeaturePropNextTables) Parse 

func (p *OfpTableFeaturePropNextTables) Parse(packet []byte)

func (*OfpTableFeaturePropNextTables) Property 

func (p *OfpTableFeaturePropNextTables) Property() uint16

func (*OfpTableFeaturePropNextTables) Serialize 

func (p *OfpTableFeaturePropNextTables) Serialize() []byte

func (*OfpTableFeaturePropNextTables) Size 

func (p *OfpTableFeaturePropNextTables) Size() int

type OfpTableFeaturePropOxm 

type OfpTableFeaturePropOxm struct {
	PropHeader OfpTableFeaturePropHeader
	OxmIds     []uint32
}

func NewOfpTableFeaturePropOxm 

func NewOfpTableFeaturePropOxm(t uint16, ids []uint32) *OfpTableFeaturePropOxm

*************************************************** 

OfpTableFeaturePropOxm

***************************************************

func (*OfpTableFeaturePropOxm) Parse 

func (p *OfpTableFeaturePropOxm) Parse(packet []byte)

func (*OfpTableFeaturePropOxm) Property 

func (p *OfpTableFeaturePropOxm) Property() uint16

func (*OfpTableFeaturePropOxm) Serialize 

func (p *OfpTableFeaturePropOxm) Serialize() []byte

func (*OfpTableFeaturePropOxm) Size 

func (p *OfpTableFeaturePropOxm) Size() int

type OfpTableFeatures 

type OfpTableFeatures struct {
	Length  uint16
	TableId uint8
	// Pad           [5]uint8
	Name          []byte
	MetadataMatch uint64
	MetadataWrite uint64
	Config        uint32
	MaxEntries    uint32
	Properties    []OfpTableFeatureProp
}

func NewOfpTableFeatures 

func NewOfpTableFeatures(
	tableId uint8,
	name []byte,
	metadataMatch uint64,
	metadataWrite uint64,
	config uint32,
	maxEntries uint32,
	properties []OfpTableFeatureProp) *OfpTableFeatures

*************************************************** 

OfpTableFeatures

***************************************************

func (*OfpTableFeatures) MPType 

func (mp *OfpTableFeatures) MPType() uint16

func (*OfpTableFeatures) Parse 

func (mp *OfpTableFeatures) Parse(packet []byte)

func (*OfpTableFeatures) Serialize 

func (mp *OfpTableFeatures) Serialize() []byte

func (*OfpTableFeatures) Size 

func (mp *OfpTableFeatures) Size() int

type OfpTableMod 

type OfpTableMod struct {
	Header  OfpHeader
	TableId uint8
	Pad     [3]uint8
	Config  uint32
}

func NewOfpTableMod 

func NewOfpTableMod(tableId uint8, config uint32) *OfpTableMod

*************************************************** 

OfpTableMod

***************************************************

func (*OfpTableMod) Parse 

func (m *OfpTableMod) Parse()

func (*OfpTableMod) Serialize 

func (m *OfpTableMod) Serialize() []byte

func (*OfpTableMod) Size 

func (m *OfpTableMod) Size() int

type OfpTableStats 

type OfpTableStats struct {
	TableId      uint8
	Pad          [3]uint8
	ActiveCount  uint32
	LookupCount  uint64
	MatchedCount uint64
}

func (*OfpTableStats) MPType 

func (mp *OfpTableStats) MPType() uint16

func (*OfpTableStats) Parse 

func (mp *OfpTableStats) Parse(packet []byte)

func (*OfpTableStats) Serialize 

func (mp *OfpTableStats) Serialize() []byte

func (*OfpTableStats) Size 

func (mp *OfpTableStats) Size() int

type OxmArpHa 

type OxmArpHa struct {
	TlvHeader uint32
	//Value     [6]uint8
	Value net.HardwareAddr
}

func NewOxmArpHa 

func NewOxmArpHa(header uint32, hwAddr string) (*OxmArpHa, error)

func NewOxmArpSha 

func NewOxmArpSha(hwAddr string) (*OxmArpHa, error)

func NewOxmArpTha 

func NewOxmArpTha(hwAddr string) (*OxmArpHa, error)

func (*OxmArpHa) Length 

func (m *OxmArpHa) Length() uint32

func (*OxmArpHa) OxmClass 

func (m *OxmArpHa) OxmClass() uint32

func (*OxmArpHa) OxmField 

func (m *OxmArpHa) OxmField() uint32

func (*OxmArpHa) OxmHasMask 

func (m *OxmArpHa) OxmHasMask() uint32

func (*OxmArpHa) Parse 

func (m *OxmArpHa) Parse(packet []byte)

func (*OxmArpHa) Serialize 

func (m *OxmArpHa) Serialize() []byte

func (*OxmArpHa) Size 

func (m *OxmArpHa) Size() int

type OxmArpOp 

type OxmArpOp struct {
	TlvHeader uint32
	Value     uint16
}

func NewOxmArpOp 

func NewOxmArpOp(op uint16) *OxmArpOp

func (*OxmArpOp) Length 

func (m *OxmArpOp) Length() uint32

func (*OxmArpOp) OxmClass 

func (m *OxmArpOp) OxmClass() uint32

func (*OxmArpOp) OxmField 

func (m *OxmArpOp) OxmField() uint32

func (*OxmArpOp) OxmHasMask 

func (m *OxmArpOp) OxmHasMask() uint32

func (*OxmArpOp) Parse 

func (m *OxmArpOp) Parse(packet []byte)

func (*OxmArpOp) Serialize 

func (m *OxmArpOp) Serialize() []byte

func (*OxmArpOp) Size 

func (m *OxmArpOp) Size() int

type OxmArpPa 

type OxmArpPa struct {
	TlvHeader uint32
	Value     net.IP
	Mask      net.IPMask
}

func NewOxmArpPa 

func NewOxmArpPa(header uint32, addr string) (*OxmArpPa, error)

func NewOxmArpPaW 

func NewOxmArpPaW(header uint32, addr string, mask int) (*OxmArpPa, error)

func NewOxmArpSpa 

func NewOxmArpSpa(addr string) (*OxmArpPa, error)

func NewOxmArpSpaW 

func NewOxmArpSpaW(addr string, mask int) (*OxmArpPa, error)

func NewOxmArpTpa 

func NewOxmArpTpa(addr string) (*OxmArpPa, error)

func NewOxmArpTpaW 

func NewOxmArpTpaW(addr string, mask int) (*OxmArpPa, error)

func (*OxmArpPa) Length 

func (m *OxmArpPa) Length() uint32

func (*OxmArpPa) OxmClass 

func (m *OxmArpPa) OxmClass() uint32

func (*OxmArpPa) OxmField 

func (m *OxmArpPa) OxmField() uint32

func (*OxmArpPa) OxmHasMask 

func (m *OxmArpPa) OxmHasMask() uint32

func (*OxmArpPa) Parse 

func (m *OxmArpPa) Parse(packet []byte)

func (*OxmArpPa) Serialize 

func (m *OxmArpPa) Serialize() []byte

func (*OxmArpPa) Size 

func (m *OxmArpPa) Size() int

type OxmEth 

type OxmEth struct {
	TlvHeader uint32
	Value     net.HardwareAddr
	Mask      net.HardwareAddr
}

func NewOxmEth 

func NewOxmEth(header uint32, hwAddr string) (*OxmEth, error)

func NewOxmEthDst 

func NewOxmEthDst(hwAddr string) (*OxmEth, error)

func NewOxmEthDstW 

func NewOxmEthDstW(hwAddr string, mask string) (*OxmEth, error)

func NewOxmEthSrc 

func NewOxmEthSrc(hwAddr string) (*OxmEth, error)

func NewOxmEthSrcW 

func NewOxmEthSrcW(hwAddr string, mask string) (*OxmEth, error)

func NewOxmEthW 

func NewOxmEthW(header uint32, hwAddr string, mask string) (*OxmEth, error)

func (*OxmEth) Length 

func (m *OxmEth) Length() uint32

func (*OxmEth) OxmClass 

func (m *OxmEth) OxmClass() uint32

func (*OxmEth) OxmField 

func (m *OxmEth) OxmField() uint32

func (*OxmEth) OxmHasMask 

func (m *OxmEth) OxmHasMask() uint32

func (*OxmEth) Parse 

func (m *OxmEth) Parse(packet []byte)

func (*OxmEth) Serialize 

func (m *OxmEth) Serialize() []byte

func (*OxmEth) Size 

func (m *OxmEth) Size() int

type OxmEthType 

type OxmEthType struct {
	TlvHeader uint32
	Value     uint16
}

func NewOxmEthType 

func NewOxmEthType(ethType uint16) *OxmEthType

func (*OxmEthType) Length 

func (m *OxmEthType) Length() uint32

func (*OxmEthType) OxmClass 

func (m *OxmEthType) OxmClass() uint32

func (*OxmEthType) OxmField 

func (m *OxmEthType) OxmField() uint32

func (*OxmEthType) OxmHasMask 

func (m *OxmEthType) OxmHasMask() uint32

func (*OxmEthType) Parse 

func (m *OxmEthType) Parse(packet []byte)

func (*OxmEthType) Serialize 

func (m *OxmEthType) Serialize() []byte

func (*OxmEthType) Size 

func (m *OxmEthType) Size() int

type OxmField 

type OxmField interface {
	Serialize() []byte
	Parse([]byte)
	OxmClass() uint32
	OxmField() uint32
	OxmHasMask() uint32
	Length() uint32
	Size() int
}

type OxmIcmpCode 

type OxmIcmpCode struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIcmpCode 

func NewOxmIcmpCode(value uint8) *OxmIcmpCode

func (*OxmIcmpCode) Length 

func (m *OxmIcmpCode) Length() uint32

func (*OxmIcmpCode) OxmClass 

func (m *OxmIcmpCode) OxmClass() uint32

func (*OxmIcmpCode) OxmField 

func (m *OxmIcmpCode) OxmField() uint32

func (*OxmIcmpCode) OxmHasMask 

func (m *OxmIcmpCode) OxmHasMask() uint32

func (*OxmIcmpCode) Parse 

func (m *OxmIcmpCode) Parse(packet []byte)

func (*OxmIcmpCode) Serialize 

func (m *OxmIcmpCode) Serialize() []byte

func (*OxmIcmpCode) Size 

func (m *OxmIcmpCode) Size() int

type OxmIcmpType 

type OxmIcmpType struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIcmpType 

func NewOxmIcmpType(value uint8) *OxmIcmpType

func (*OxmIcmpType) Length 

func (m *OxmIcmpType) Length() uint32

func (*OxmIcmpType) OxmClass 

func (m *OxmIcmpType) OxmClass() uint32

func (*OxmIcmpType) OxmField 

func (m *OxmIcmpType) OxmField() uint32

func (*OxmIcmpType) OxmHasMask 

func (m *OxmIcmpType) OxmHasMask() uint32

func (*OxmIcmpType) Parse 

func (m *OxmIcmpType) Parse(packet []byte)

func (*OxmIcmpType) Serialize 

func (m *OxmIcmpType) Serialize() []byte

func (*OxmIcmpType) Size 

func (m *OxmIcmpType) Size() int

type OxmIcmpv6Code 

type OxmIcmpv6Code struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIcmpv6Code 

func NewOxmIcmpv6Code(value uint8) *OxmIcmpv6Code

func (*OxmIcmpv6Code) Length 

func (m *OxmIcmpv6Code) Length() uint32

func (*OxmIcmpv6Code) OxmClass 

func (m *OxmIcmpv6Code) OxmClass() uint32

func (*OxmIcmpv6Code) OxmField 

func (m *OxmIcmpv6Code) OxmField() uint32

func (*OxmIcmpv6Code) OxmHasMask 

func (m *OxmIcmpv6Code) OxmHasMask() uint32

func (*OxmIcmpv6Code) Parse 

func (m *OxmIcmpv6Code) Parse(packet []byte)

func (*OxmIcmpv6Code) Serialize 

func (m *OxmIcmpv6Code) Serialize() []byte

func (*OxmIcmpv6Code) Size 

func (m *OxmIcmpv6Code) Size() int

type OxmIcmpv6Type 

type OxmIcmpv6Type struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIcmpv6Type 

func NewOxmIcmpv6Type(value uint8) *OxmIcmpv6Type

func (*OxmIcmpv6Type) Length 

func (m *OxmIcmpv6Type) Length() uint32

func (*OxmIcmpv6Type) OxmClass 

func (m *OxmIcmpv6Type) OxmClass() uint32

func (*OxmIcmpv6Type) OxmField 

func (m *OxmIcmpv6Type) OxmField() uint32

func (*OxmIcmpv6Type) OxmHasMask 

func (m *OxmIcmpv6Type) OxmHasMask() uint32

func (*OxmIcmpv6Type) Parse 

func (m *OxmIcmpv6Type) Parse(packet []byte)

func (*OxmIcmpv6Type) Serialize 

func (m *OxmIcmpv6Type) Serialize() []byte

func (*OxmIcmpv6Type) Size 

func (m *OxmIcmpv6Type) Size() int

type OxmInPhyPort 

type OxmInPhyPort struct {
	TlvHeader uint32
	Value     uint32
}

func NewOxmInPhyPort 

func NewOxmInPhyPort(port uint32) *OxmInPhyPort

func (*OxmInPhyPort) Length 

func (m *OxmInPhyPort) Length() uint32

func (*OxmInPhyPort) OxmClass 

func (m *OxmInPhyPort) OxmClass() uint32

func (*OxmInPhyPort) OxmField 

func (m *OxmInPhyPort) OxmField() uint32

func (*OxmInPhyPort) OxmHasMask 

func (m *OxmInPhyPort) OxmHasMask() uint32

func (*OxmInPhyPort) Parse 

func (m *OxmInPhyPort) Parse(packet []byte)

func (*OxmInPhyPort) Serialize 

func (m *OxmInPhyPort) Serialize() []byte

func (*OxmInPhyPort) Size 

func (m *OxmInPhyPort) Size() int

type OxmInPort 

type OxmInPort struct {
	TlvHeader uint32
	Value     uint32
}

func NewOxmInPort 

func NewOxmInPort(port uint32) *OxmInPort

*

func (*OxmInPort) Length 

func (m *OxmInPort) Length() uint32

Length

func (*OxmInPort) OxmClass 

func (m *OxmInPort) OxmClass() uint32

OxmClass

func (*OxmInPort) OxmField 

func (m *OxmInPort) OxmField() uint32

OxmField

func (*OxmInPort) OxmHasMask 

func (m *OxmInPort) OxmHasMask() uint32

OxmHasMask

func (*OxmInPort) Parse 

func (m *OxmInPort) Parse(packet []byte)

Parse

func (*OxmInPort) Serialize 

func (m *OxmInPort) Serialize() []byte

Serialize

func (*OxmInPort) Size 

func (m *OxmInPort) Size() int

type OxmIpDscp 

type OxmIpDscp struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIpDscp 

func NewOxmIpDscp(dscp uint8) *OxmIpDscp

func (*OxmIpDscp) Length 

func (m *OxmIpDscp) Length() uint32

func (*OxmIpDscp) OxmClass 

func (m *OxmIpDscp) OxmClass() uint32

func (*OxmIpDscp) OxmField 

func (m *OxmIpDscp) OxmField() uint32

func (*OxmIpDscp) OxmHasMask 

func (m *OxmIpDscp) OxmHasMask() uint32

func (*OxmIpDscp) Parse 

func (m *OxmIpDscp) Parse(packet []byte)

func (*OxmIpDscp) Serialize 

func (m *OxmIpDscp) Serialize() []byte

func (*OxmIpDscp) Size 

func (m *OxmIpDscp) Size() int

type OxmIpEcn 

type OxmIpEcn struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIpEcn 

func NewOxmIpEcn(ecn uint8) *OxmIpEcn

func (*OxmIpEcn) Length 

func (m *OxmIpEcn) Length() uint32

func (*OxmIpEcn) OxmClass 

func (m *OxmIpEcn) OxmClass() uint32

func (*OxmIpEcn) OxmField 

func (m *OxmIpEcn) OxmField() uint32

func (*OxmIpEcn) OxmHasMask 

func (m *OxmIpEcn) OxmHasMask() uint32

func (*OxmIpEcn) Parse 

func (m *OxmIpEcn) Parse(packet []byte)

func (*OxmIpEcn) Serialize 

func (m *OxmIpEcn) Serialize() []byte

func (*OxmIpEcn) Size 

func (m *OxmIpEcn) Size() int

type OxmIpProto 

type OxmIpProto struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmIpProto 

func NewOxmIpProto(proto uint8) *OxmIpProto

func (*OxmIpProto) Length 

func (m *OxmIpProto) Length() uint32

func (*OxmIpProto) OxmClass 

func (m *OxmIpProto) OxmClass() uint32

func (*OxmIpProto) OxmField 

func (m *OxmIpProto) OxmField() uint32

func (*OxmIpProto) OxmHasMask 

func (m *OxmIpProto) OxmHasMask() uint32

func (*OxmIpProto) Parse 

func (m *OxmIpProto) Parse(packet []byte)

func (*OxmIpProto) Serialize 

func (m *OxmIpProto) Serialize() []byte

func (*OxmIpProto) Size 

func (m *OxmIpProto) Size() int

type OxmIpv4 

type OxmIpv4 struct {
	TlvHeader uint32
	Value     net.IP
	Mask      net.IPMask
}

func NewOxmIpv4 

func NewOxmIpv4(header uint32, addr string) (*OxmIpv4, error)

func NewOxmIpv4Dst 

func NewOxmIpv4Dst(addr string) (*OxmIpv4, error)

func NewOxmIpv4DstW 

func NewOxmIpv4DstW(addr string, mask int) (*OxmIpv4, error)

func NewOxmIpv4Src 

func NewOxmIpv4Src(addr string) (*OxmIpv4, error)

func NewOxmIpv4SrcW 

func NewOxmIpv4SrcW(addr string, mask int) (*OxmIpv4, error)

func NewOxmIpv4W 

func NewOxmIpv4W(header uint32, addr string, mask int) (*OxmIpv4, error)

func (*OxmIpv4) Length 

func (m *OxmIpv4) Length() uint32

func (*OxmIpv4) OxmClass 

func (m *OxmIpv4) OxmClass() uint32

func (*OxmIpv4) OxmField 

func (m *OxmIpv4) OxmField() uint32

func (*OxmIpv4) OxmHasMask 

func (m *OxmIpv4) OxmHasMask() uint32

func (*OxmIpv4) Parse 

func (m *OxmIpv4) Parse(packet []byte)

func (*OxmIpv4) Serialize 

func (m *OxmIpv4) Serialize() []byte

func (*OxmIpv4) Size 

func (m *OxmIpv4) Size() int

type OxmIpv6 

type OxmIpv6 struct {
	TlvHeader uint32
	Value     net.IP
	Mask      net.IPMask
}

func NewOxmIpv6 

func NewOxmIpv6(header uint32, addr string) (*OxmIpv6, error)

func NewOxmIpv6Dst 

func NewOxmIpv6Dst(addr string) (*OxmIpv6, error)

func NewOxmIpv6DstW 

func NewOxmIpv6DstW(addr string, mask int) (*OxmIpv6, error)

func NewOxmIpv6Src 

func NewOxmIpv6Src(addr string) (*OxmIpv6, error)

func NewOxmIpv6SrcW 

func NewOxmIpv6SrcW(addr string, mask int) (*OxmIpv6, error)

func NewOxmIpv6W 

func NewOxmIpv6W(header uint32, addr string, mask int) (*OxmIpv6, error)

func (*OxmIpv6) Length 

func (m *OxmIpv6) Length() uint32

func (*OxmIpv6) OxmClass 

func (m *OxmIpv6) OxmClass() uint32

func (*OxmIpv6) OxmField 

func (m *OxmIpv6) OxmField() uint32

func (*OxmIpv6) OxmHasMask 

func (m *OxmIpv6) OxmHasMask() uint32

func (*OxmIpv6) Parse 

func (m *OxmIpv6) Parse(packet []byte)

func (*OxmIpv6) Serialize 

func (m *OxmIpv6) Serialize() []byte

func (*OxmIpv6) Size 

func (m *OxmIpv6) Size() int

type OxmIpv6ExtHeader 

type OxmIpv6ExtHeader struct {
	TlvHeader uint32
	Value     uint16
	Mask      uint16
}

func NewOxmIpv6ExtHeader 

func NewOxmIpv6ExtHeader(value uint16) *OxmIpv6ExtHeader

func NewOxmIpv6ExtHeaderW 

func NewOxmIpv6ExtHeaderW(value uint16, mask uint16) *OxmIpv6ExtHeader

func (*OxmIpv6ExtHeader) Length 

func (m *OxmIpv6ExtHeader) Length() uint32

func (*OxmIpv6ExtHeader) OxmClass 

func (m *OxmIpv6ExtHeader) OxmClass() uint32

func (*OxmIpv6ExtHeader) OxmField 

func (m *OxmIpv6ExtHeader) OxmField() uint32

func (*OxmIpv6ExtHeader) OxmHasMask 

func (m *OxmIpv6ExtHeader) OxmHasMask() uint32

func (*OxmIpv6ExtHeader) Parse 

func (m *OxmIpv6ExtHeader) Parse(packet []byte)

func (*OxmIpv6ExtHeader) Serialize 

func (m *OxmIpv6ExtHeader) Serialize() []byte

func (*OxmIpv6ExtHeader) Size 

func (m *OxmIpv6ExtHeader) Size() int

type OxmIpv6FLabel 

type OxmIpv6FLabel struct {
	TlvHeader uint32
	Value     uint32
	Mask      uint32
}

func NewOxmIpv6FLabel 

func NewOxmIpv6FLabel(label uint32) *OxmIpv6FLabel

func NewOxmIpv6FLabelW 

func NewOxmIpv6FLabelW(label uint32, mask uint32) *OxmIpv6FLabel

func (*OxmIpv6FLabel) Length 

func (m *OxmIpv6FLabel) Length() uint32

func (*OxmIpv6FLabel) OxmClass 

func (m *OxmIpv6FLabel) OxmClass() uint32

func (*OxmIpv6FLabel) OxmField 

func (m *OxmIpv6FLabel) OxmField() uint32

func (*OxmIpv6FLabel) OxmHasMask 

func (m *OxmIpv6FLabel) OxmHasMask() uint32

func (*OxmIpv6FLabel) Parse 

func (m *OxmIpv6FLabel) Parse(packet []byte)

func (*OxmIpv6FLabel) Serialize 

func (m *OxmIpv6FLabel) Serialize() []byte

func (*OxmIpv6FLabel) Size 

func (m *OxmIpv6FLabel) Size() int

type OxmIpv6NdSll 

type OxmIpv6NdSll struct {
	TlvHeader uint32
	// Value     [6]uint8
	Value net.HardwareAddr
}

func NewOxmIpv6NdSll 

func NewOxmIpv6NdSll(hwAddr string) (*OxmIpv6NdSll, error)

func (*OxmIpv6NdSll) Length 

func (m *OxmIpv6NdSll) Length() uint32

func (*OxmIpv6NdSll) OxmClass 

func (m *OxmIpv6NdSll) OxmClass() uint32

func (*OxmIpv6NdSll) OxmField 

func (m *OxmIpv6NdSll) OxmField() uint32

func (*OxmIpv6NdSll) OxmHasMask 

func (m *OxmIpv6NdSll) OxmHasMask() uint32

func (*OxmIpv6NdSll) Parse 

func (m *OxmIpv6NdSll) Parse(packet []byte)

func (*OxmIpv6NdSll) Serialize 

func (m *OxmIpv6NdSll) Serialize() []byte

func (*OxmIpv6NdSll) Size 

func (m *OxmIpv6NdSll) Size() int

type OxmIpv6NdTarget 

type OxmIpv6NdTarget struct {
	TlvHeader uint32
	Value     net.IP
}

func NewOxmIpv6NdTarget 

func NewOxmIpv6NdTarget(addr string) (*OxmIpv6NdTarget, error)

func (*OxmIpv6NdTarget) Length 

func (m *OxmIpv6NdTarget) Length() uint32

func (*OxmIpv6NdTarget) OxmClass 

func (m *OxmIpv6NdTarget) OxmClass() uint32

func (*OxmIpv6NdTarget) OxmField 

func (m *OxmIpv6NdTarget) OxmField() uint32

func (*OxmIpv6NdTarget) OxmHasMask 

func (m *OxmIpv6NdTarget) OxmHasMask() uint32

func (*OxmIpv6NdTarget) Parse 

func (m *OxmIpv6NdTarget) Parse(packet []byte)

func (*OxmIpv6NdTarget) Serialize 

func (m *OxmIpv6NdTarget) Serialize() []byte

func (*OxmIpv6NdTarget) Size 

func (m *OxmIpv6NdTarget) Size() int

type OxmIpv6NdTll 

type OxmIpv6NdTll struct {
	TlvHeader uint32
	// Value     [6]uint8
	Value net.HardwareAddr
}

func NewOxmIpv6NdTll 

func NewOxmIpv6NdTll(hwAddr string) (*OxmIpv6NdTll, error)

func (*OxmIpv6NdTll) Length 

func (m *OxmIpv6NdTll) Length() uint32

func (*OxmIpv6NdTll) OxmClass 

func (m *OxmIpv6NdTll) OxmClass() uint32

func (*OxmIpv6NdTll) OxmField 

func (m *OxmIpv6NdTll) OxmField() uint32

func (*OxmIpv6NdTll) OxmHasMask 

func (m *OxmIpv6NdTll) OxmHasMask() uint32

func (*OxmIpv6NdTll) Parse 

func (m *OxmIpv6NdTll) Parse(packet []byte)

func (*OxmIpv6NdTll) Serialize 

func (m *OxmIpv6NdTll) Serialize() []byte

func (*OxmIpv6NdTll) Size 

func (m *OxmIpv6NdTll) Size() int

type OxmMetadata 

type OxmMetadata struct {
	TlvHeader uint32
	Value     uint64
	Mask      uint64
}

func NewOxmMetadata 

func NewOxmMetadata(metadata uint64) *OxmMetadata

func NewOxmMetadataW 

func NewOxmMetadataW(metadata uint64, mask uint64) *OxmMetadata

func (*OxmMetadata) Length 

func (m *OxmMetadata) Length() uint32

func (*OxmMetadata) OxmClass 

func (m *OxmMetadata) OxmClass() uint32

func (*OxmMetadata) OxmField 

func (m *OxmMetadata) OxmField() uint32

func (*OxmMetadata) OxmHasMask 

func (m *OxmMetadata) OxmHasMask() uint32

func (*OxmMetadata) Parse 

func (m *OxmMetadata) Parse(packet []byte)

func (*OxmMetadata) Serialize 

func (m *OxmMetadata) Serialize() []byte

func (*OxmMetadata) Size 

func (m *OxmMetadata) Size() int

type OxmMplsBos 

type OxmMplsBos struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmMplsBos 

func NewOxmMplsBos(bos uint8) *OxmMplsBos

func (*OxmMplsBos) Length 

func (m *OxmMplsBos) Length() uint32

func (*OxmMplsBos) OxmClass 

func (m *OxmMplsBos) OxmClass() uint32

func (*OxmMplsBos) OxmField 

func (m *OxmMplsBos) OxmField() uint32

func (*OxmMplsBos) OxmHasMask 

func (m *OxmMplsBos) OxmHasMask() uint32

func (*OxmMplsBos) Parse 

func (m *OxmMplsBos) Parse(packet []byte)

func (*OxmMplsBos) Serialize 

func (m *OxmMplsBos) Serialize() []byte

func (*OxmMplsBos) Size 

func (m *OxmMplsBos) Size() int

type OxmMplsLabel 

type OxmMplsLabel struct {
	TlvHeader uint32
	Value     uint32
}

func NewOxmMplsLabel 

func NewOxmMplsLabel(label uint32) *OxmMplsLabel

func (*OxmMplsLabel) Length 

func (m *OxmMplsLabel) Length() uint32

func (*OxmMplsLabel) OxmClass 

func (m *OxmMplsLabel) OxmClass() uint32

func (*OxmMplsLabel) OxmField 

func (m *OxmMplsLabel) OxmField() uint32

func (*OxmMplsLabel) OxmHasMask 

func (m *OxmMplsLabel) OxmHasMask() uint32

func (*OxmMplsLabel) Parse 

func (m *OxmMplsLabel) Parse(packet []byte)

func (*OxmMplsLabel) Serialize 

func (m *OxmMplsLabel) Serialize() []byte

func (*OxmMplsLabel) Size 

func (m *OxmMplsLabel) Size() int

type OxmMplsTc 

type OxmMplsTc struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmMplsTc 

func NewOxmMplsTc(tc uint8) *OxmMplsTc

func (*OxmMplsTc) Length 

func (m *OxmMplsTc) Length() uint32

func (*OxmMplsTc) OxmClass 

func (m *OxmMplsTc) OxmClass() uint32

func (*OxmMplsTc) OxmField 

func (m *OxmMplsTc) OxmField() uint32

func (*OxmMplsTc) OxmHasMask 

func (m *OxmMplsTc) OxmHasMask() uint32

func (*OxmMplsTc) Parse 

func (m *OxmMplsTc) Parse(packet []byte)

func (*OxmMplsTc) Serialize 

func (m *OxmMplsTc) Serialize() []byte

func (*OxmMplsTc) Size 

func (m *OxmMplsTc) Size() int

type OxmPbbIsid 

type OxmPbbIsid struct {
	TlvHeader uint32
	Value     [3]uint8
	Mask      [3]uint8
}

func NewOxmPbbIsid 

func NewOxmPbbIsid(isid [3]uint8) *OxmPbbIsid

func NewOxmPbbIsidW 

func NewOxmPbbIsidW(isid [3]uint8, mask [3]uint8) *OxmPbbIsid

func (*OxmPbbIsid) Length 

func (m *OxmPbbIsid) Length() uint32

func (*OxmPbbIsid) OxmClass 

func (m *OxmPbbIsid) OxmClass() uint32

func (*OxmPbbIsid) OxmField 

func (m *OxmPbbIsid) OxmField() uint32

func (*OxmPbbIsid) OxmHasMask 

func (m *OxmPbbIsid) OxmHasMask() uint32

func (*OxmPbbIsid) Parse 

func (m *OxmPbbIsid) Parse(packet []byte)

func (*OxmPbbIsid) Serialize 

func (m *OxmPbbIsid) Serialize() []byte

func (*OxmPbbIsid) Size 

func (m *OxmPbbIsid) Size() int

type OxmSctp 

type OxmSctp struct {
	TlvHeader uint32
	Value     uint16
}

func NewOxmSctp 

func NewOxmSctp(header uint32, port uint16) *OxmSctp

func NewOxmSctpDst 

func NewOxmSctpDst(port uint16) *OxmSctp

func NewOxmSctpSrc 

func NewOxmSctpSrc(port uint16) *OxmSctp

func (*OxmSctp) Length 

func (m *OxmSctp) Length() uint32

func (*OxmSctp) OxmClass 

func (m *OxmSctp) OxmClass() uint32

func (*OxmSctp) OxmField 

func (m *OxmSctp) OxmField() uint32

func (*OxmSctp) OxmHasMask 

func (m *OxmSctp) OxmHasMask() uint32

func (*OxmSctp) Parse 

func (m *OxmSctp) Parse(packet []byte)

func (*OxmSctp) Serialize 

func (m *OxmSctp) Serialize() []byte

func (*OxmSctp) Size 

func (m *OxmSctp) Size() int

type OxmTcp 

type OxmTcp struct {
	TlvHeader uint32
	Value     uint16
}

func NewOxmTcp 

func NewOxmTcp(header uint32, port uint16) *OxmTcp

func NewOxmTcpDst 

func NewOxmTcpDst(port uint16) *OxmTcp

func NewOxmTcpSrc 

func NewOxmTcpSrc(port uint16) *OxmTcp

func (*OxmTcp) Length 

func (m *OxmTcp) Length() uint32

func (*OxmTcp) OxmClass 

func (m *OxmTcp) OxmClass() uint32

func (*OxmTcp) OxmField 

func (m *OxmTcp) OxmField() uint32

func (*OxmTcp) OxmHasMask 

func (m *OxmTcp) OxmHasMask() uint32

func (*OxmTcp) Parse 

func (m *OxmTcp) Parse(packet []byte)

func (*OxmTcp) Serialize 

func (m *OxmTcp) Serialize() []byte

func (*OxmTcp) Size 

func (m *OxmTcp) Size() int

type OxmTunnelId 

type OxmTunnelId struct {
	TlvHeader uint32
	Value     uint64
	Mask      uint64
}

func NewOxmTunnelId 

func NewOxmTunnelId(id uint64) *OxmTunnelId

func NewOxmTunnelIdW 

func NewOxmTunnelIdW(id uint64, mask uint64) *OxmTunnelId

func (*OxmTunnelId) Length 

func (m *OxmTunnelId) Length() uint32

func (*OxmTunnelId) OxmClass 

func (m *OxmTunnelId) OxmClass() uint32

func (*OxmTunnelId) OxmField 

func (m *OxmTunnelId) OxmField() uint32

func (*OxmTunnelId) OxmHasMask 

func (m *OxmTunnelId) OxmHasMask() uint32

func (*OxmTunnelId) Parse 

func (m *OxmTunnelId) Parse(packet []byte)

func (*OxmTunnelId) Serialize 

func (m *OxmTunnelId) Serialize() []byte

func (*OxmTunnelId) Size 

func (m *OxmTunnelId) Size() int

type OxmUdp 

type OxmUdp struct {
	TlvHeader uint32
	Value     uint16
}

func NewOxmUdp 

func NewOxmUdp(header uint32, port uint16) *OxmUdp

func NewOxmUdpDst 

func NewOxmUdpDst(port uint16) *OxmUdp

func NewOxmUdpSrc 

func NewOxmUdpSrc(port uint16) *OxmUdp

func (*OxmUdp) Length 

func (m *OxmUdp) Length() uint32

func (*OxmUdp) OxmClass 

func (m *OxmUdp) OxmClass() uint32

func (*OxmUdp) OxmField 

func (m *OxmUdp) OxmField() uint32

func (*OxmUdp) OxmHasMask 

func (m *OxmUdp) OxmHasMask() uint32

func (*OxmUdp) Parse 

func (m *OxmUdp) Parse(packet []byte)

func (*OxmUdp) Serialize 

func (m *OxmUdp) Serialize() []byte

func (*OxmUdp) Size 

func (m *OxmUdp) Size() int

type OxmVlanPcp 

type OxmVlanPcp struct {
	TlvHeader uint32
	Value     uint8
}

func NewOxmVlanPcp 

func NewOxmVlanPcp(pcp uint8) *OxmVlanPcp

func (*OxmVlanPcp) Length 

func (m *OxmVlanPcp) Length() uint32

func (*OxmVlanPcp) OxmClass 

func (m *OxmVlanPcp) OxmClass() uint32

func (*OxmVlanPcp) OxmField 

func (m *OxmVlanPcp) OxmField() uint32

func (*OxmVlanPcp) OxmHasMask 

func (m *OxmVlanPcp) OxmHasMask() uint32

func (*OxmVlanPcp) Parse 

func (m *OxmVlanPcp) Parse(packet []byte)

func (*OxmVlanPcp) Serialize 

func (m *OxmVlanPcp) Serialize() []byte

func (*OxmVlanPcp) Size 

func (m *OxmVlanPcp) Size() int

type OxmVlanVid 

type OxmVlanVid struct {
	TlvHeader uint32
	Value     uint16
	Mask      uint16
}

func NewOxmVlanVid 

func NewOxmVlanVid(vid uint16) *OxmVlanVid

func NewOxmVlanVidW 

func NewOxmVlanVidW(vid uint16, mask uint16) *OxmVlanVid

func (*OxmVlanVid) Length 

func (m *OxmVlanVid) Length() uint32

func (*OxmVlanVid) OxmClass 

func (m *OxmVlanVid) OxmClass() uint32

func (*OxmVlanVid) OxmField 

func (m *OxmVlanVid) OxmField() uint32

func (*OxmVlanVid) OxmHasMask 

func (m *OxmVlanVid) OxmHasMask() uint32

func (*OxmVlanVid) Parse 

func (m *OxmVlanVid) Parse(packet []byte)

func (*OxmVlanVid) Serialize 

func (m *OxmVlanVid) Serialize() []byte

func (*OxmVlanVid) Size 

func (m *OxmVlanVid) Size() int

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.