Source code for faucet.valve_of

"""Utility functions to parse/create OpenFlow messages."""

# pylint: disable=too-many-lines

# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
# Copyright (C) 2015 Brad Cowie, Christopher Lorier and Joe Stringer.
# Copyright (C) 2015 Research and Education Advanced Network New Zealand Ltd.
# Copyright (C) 2015--2019 The Contributors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import functools
import ipaddress
import random

# pylint: disable=unused-import
from os_ken.lib import mac  # noqa: F401
from os_ken.lib import ofctl_v1_3 as ofctl
from os_ken.lib.ofctl_utils import (
    str_to_int,
    to_match_ip,
    to_match_masked_int,
    to_match_eth,
    to_match_vid,
    OFCtlUtil,
)
from os_ken.ofproto import ether

# pylint: disable=unused-import
from os_ken.ofproto import inet  # noqa: F401
from os_ken.ofproto import ofproto_v1_3 as ofp
from os_ken.ofproto import ofproto_v1_3_parser as parser

from faucet.conf import test_config_condition, InvalidConfigError
from faucet.valve_of_old import OLD_MATCH_FIELDS

MIN_VID = 1
MAX_VID = 4095
VLAN_GROUP_OFFSET = MAX_VID + 1
ROUTE_GROUP_OFFSET = VLAN_GROUP_OFFSET * 2
OFP_VERSIONS = [ofp.OFP_VERSION]
OFP_IN_PORT = ofp.OFPP_IN_PORT
MAX_PACKET_IN_BYTES = 194  # largest packet is icmp6 echo req with 128 byte payload
ECTP_ETH_TYPE = 0x9000

# https://en.wikipedia.org/wiki/IEEE_P802.1p
# Avoid use of PCP 1 which is BK priority (lowest)

TUNNEL_INDICATOR_FIELD = "vlan_pcp"
# Used to indicate traffic in a one-to-one bi-directional tunnel is heading
# in the reverse/return direction
PCP_TUNNEL_REVERSE_DIRECTION_FLAG = 4
# Used to indicate traffic belongs in a tunnel (for all cases not including
# the 1-1 reverse bi-directional tunnel)
PCP_TUNNEL_FLAG = 3

PCP_EXT_PORT_FLAG = 2
PCP_NONEXT_PORT_FLAG = 0
EXTERNAL_FORWARDING_FIELD = "vlan_pcp"


OFERROR_TYPE_CODE = {
    ofp.OFPET_HELLO_FAILED: (
        "OFPET_HELLO_FAILED",
        {
            ofp.OFPHFC_INCOMPATIBLE: "OFPHFC_INCOMPATIBLE",
            ofp.OFPHFC_EPERM: "OFPHFC_EPERM",
        },
    ),
    ofp.OFPET_BAD_REQUEST: (
        "OFPET_BAD_REQUEST",
        {
            ofp.OFPBRC_BAD_VERSION: "OFPBRC_BAD_VERSION",
            ofp.OFPBRC_BAD_TYPE: "OFPBRC_BAD_TYPE",
            ofp.OFPBRC_BAD_MULTIPART: "OFPBRC_BAD_MULTIPART",
            ofp.OFPBRC_BAD_EXPERIMENTER: "OFPBRC_BAD_EXPERIMENTER",
            ofp.OFPBRC_BAD_EXP_TYPE: "OFPBRC_BAD_EXP_TYPE",
            ofp.OFPBRC_EPERM: "OFPBRC_EPERM",
            ofp.OFPBRC_BAD_LEN: "OFPBRC_BAD_LEN",
            ofp.OFPBRC_BUFFER_EMPTY: "OFPBRC_BUFFER_EMPTY",
            ofp.OFPBRC_BUFFER_UNKNOWN: "OFPBRC_BUFFER_UNKNOWN",
            ofp.OFPBRC_BAD_TABLE_ID: "OFPBRC_BAD_TABLE_ID",
            ofp.OFPBRC_IS_SLAVE: "OFPBRC_IS_SLAVE",
            ofp.OFPBRC_BAD_PORT: "OFPBRC_BAD_PORT",
            ofp.OFPBRC_BAD_PACKET: "OFPBRC_BAD_PACKET",
            ofp.OFPBRC_MULTIPART_BUFFER_OVERFLOW: "OFPBRC_MULTIPART_BUFFER_OVERFLOW",
        },
    ),
    ofp.OFPET_BAD_ACTION: (
        "OFPET_BAD_ACTION",
        {
            ofp.OFPBAC_BAD_TYPE: "OFPBAC_BAD_TYPE",
            ofp.OFPBAC_BAD_LEN: "OFPBAC_BAD_LEN",
            ofp.OFPBAC_BAD_EXPERIMENTER: "OFPBAC_BAD_EXPERIMENTER",
            ofp.OFPBAC_BAD_EXP_TYPE: "OFPBAC_BAD_EXP_TYPE",
            ofp.OFPBAC_BAD_OUT_PORT: "OFPBAC_BAD_OUT_PORT",
            ofp.OFPBAC_BAD_ARGUMENT: "OFPBAC_BAD_ARGUMENT",
            ofp.OFPBAC_EPERM: "OFPBAC_EPERM",
            ofp.OFPBAC_TOO_MANY: "OFPBAC_TOO_MANY",
            ofp.OFPBAC_BAD_QUEUE: "OFPBAC_BAD_QUEUE",
            ofp.OFPBAC_BAD_OUT_GROUP: "OFPBAC_BAD_OUT_GROUP",
            ofp.OFPBAC_MATCH_INCONSISTENT: "OFPBAC_MATCH_INCONSISTENT",
            ofp.OFPBAC_UNSUPPORTED_ORDER: "OFPBAC_UNSUPPORTED_ORDER",
            ofp.OFPBAC_BAD_TAG: "OFPBAC_BAD_TAG",
            ofp.OFPBAC_BAD_SET_TYPE: "OFPBAC_BAD_SET_TYPE",
            ofp.OFPBAC_BAD_SET_LEN: "OFPBAC_BAD_SET_LEN",
            ofp.OFPBAC_BAD_SET_ARGUMENT: "OFPBAC_BAD_SET_ARGUMENT",
        },
    ),
    ofp.OFPET_BAD_INSTRUCTION: (
        "OFPET_BAD_INSTRUCTION",
        {
            ofp.OFPBIC_UNKNOWN_INST: "OFPBIC_UNKNOWN_INST",
            ofp.OFPBIC_UNSUP_INST: "OFPBIC_UNSUP_INST",
            ofp.OFPBIC_BAD_TABLE_ID: "OFPBIC_BAD_TABLE_ID",
            ofp.OFPBIC_UNSUP_METADATA: "OFPBIC_UNSUP_METADATA",
            ofp.OFPBIC_UNSUP_METADATA_MASK: "OFPBIC_UNSUP_METADATA_MASK",
            ofp.OFPBIC_BAD_EXPERIMENTER: "OFPBIC_BAD_EXPERIMENTER",
            ofp.OFPBIC_BAD_EXP_TYPE: "OFPBIC_BAD_EXP_TYPE",
            ofp.OFPBIC_BAD_LEN: "OFPBIC_BAD_LEN",
            ofp.OFPBIC_EPERM: "OFPBIC_EPERM",
        },
    ),
    ofp.OFPET_BAD_MATCH: (
        "OFPET_BAD_MATCH",
        {
            ofp.OFPBMC_BAD_TYPE: "OFPBMC_BAD_TYPE",
            ofp.OFPBMC_BAD_LEN: "OFPBMC_BAD_LEN",
            ofp.OFPBMC_BAD_TAG: "OFPBMC_BAD_TAG",
            ofp.OFPBMC_BAD_DL_ADDR_MASK: "OFPBMC_BAD_DL_ADDR_MASK",
            ofp.OFPBMC_BAD_NW_ADDR_MASK: "OFPBMC_BAD_NW_ADDR_MASK",
            ofp.OFPBMC_BAD_WILDCARDS: "OFPBMC_BAD_WILDCARDS",
            ofp.OFPBMC_BAD_FIELD: "OFPBMC_BAD_FIELD",
            ofp.OFPBMC_BAD_VALUE: "OFPBMC_BAD_VALUE",
            ofp.OFPBMC_BAD_MASK: "OFPBMC_BAD_MASK",
            ofp.OFPBMC_BAD_PREREQ: "OFPBMC_BAD_PREREQ",
            ofp.OFPBMC_DUP_FIELD: "OFPBMC_DUP_FIELD",
            ofp.OFPBMC_EPERM: "OFPBMC_EPERM",
        },
    ),
    ofp.OFPET_FLOW_MOD_FAILED: (
        "OFPET_FLOW_MOD_FAILED",
        {
            ofp.OFPFMFC_UNKNOWN: "OFPFMFC_UNKNOWN",
            ofp.OFPFMFC_TABLE_FULL: "OFPFMFC_TABLE_FULL",
            ofp.OFPFMFC_BAD_TABLE_ID: "OFPFMFC_BAD_TABLE_ID",
            ofp.OFPFMFC_OVERLAP: "OFPFMFC_OVERLAP",
            ofp.OFPFMFC_EPERM: "OFPFMFC_EPERM",
            ofp.OFPFMFC_BAD_TIMEOUT: "OFPFMFC_BAD_TIMEOUT",
            ofp.OFPFMFC_BAD_COMMAND: "OFPFMFC_BAD_COMMAND",
            ofp.OFPFMFC_BAD_FLAGS: "OFPFMFC_BAD_FLAGS",
        },
    ),
    ofp.OFPET_GROUP_MOD_FAILED: (
        "OFPET_GROUP_MOD_FAILED",
        {
            ofp.OFPGMFC_GROUP_EXISTS: "OFPGMFC_GROUP_EXISTS",
            ofp.OFPGMFC_INVALID_GROUP: "OFPGMFC_INVALID_GROUP",
            ofp.OFPGMFC_WEIGHT_UNSUPPORTED: "OFPGMFC_WEIGHT_UNSUPPORTED",
            ofp.OFPGMFC_OUT_OF_GROUPS: "OFPGMFC_OUT_OF_GROUPS",
            ofp.OFPGMFC_OUT_OF_BUCKETS: "OFPGMFC_OUT_OF_BUCKETS",
            ofp.OFPGMFC_CHAINING_UNSUPPORTED: "OFPGMFC_CHAINING_UNSUPPORTED",
            ofp.OFPGMFC_WATCH_UNSUPPORTED: "OFPGMFC_WATCH_UNSUPPORTED",
            ofp.OFPGMFC_LOOP: "OFPGMFC_LOOP",
            ofp.OFPGMFC_UNKNOWN_GROUP: "OFPGMFC_UNKNOWN_GROUP",
            ofp.OFPGMFC_CHAINED_GROUP: "OFPGMFC_CHAINED_GROUP",
            ofp.OFPGMFC_BAD_TYPE: "OFPGMFC_BAD_TYPE",
            ofp.OFPGMFC_BAD_COMMAND: "OFPGMFC_BAD_COMMAND",
            ofp.OFPGMFC_BAD_BUCKET: "OFPGMFC_BAD_BUCKET",
            ofp.OFPGMFC_BAD_WATCH: "OFPGMFC_BAD_WATCH",
            ofp.OFPGMFC_EPERM: "OFPGMFC_EPERM",
        },
    ),
    ofp.OFPET_PORT_MOD_FAILED: (
        "OFPET_PORT_MOD_FAILED",
        {
            ofp.OFPPMFC_BAD_PORT: "OFPPMFC_BAD_PORT",
            ofp.OFPPMFC_BAD_HW_ADDR: "OFPPMFC_BAD_HW_ADDR",
            ofp.OFPPMFC_BAD_CONFIG: "OFPPMFC_BAD_CONFIG",
            ofp.OFPPMFC_BAD_ADVERTISE: "OFPPMFC_BAD_ADVERTISE",
            ofp.OFPPMFC_EPERM: "OFPPMFC_EPERM",
        },
    ),
    ofp.OFPET_TABLE_MOD_FAILED: (
        "OFPET_TABLE_MOD_FAILED",
        {
            ofp.OFPTMFC_BAD_TABLE: "OFPTMFC_BAD_TABLE",
            ofp.OFPTMFC_BAD_CONFIG: "OFPTMFC_BAD_CONFIG",
            ofp.OFPTMFC_EPERM: "OFPTMFC_EPERM",
        },
    ),
    ofp.OFPET_QUEUE_OP_FAILED: (
        "OFPET_QUEUE_OP_FAILED",
        {
            ofp.OFPQOFC_BAD_PORT: "OFPQOFC_BAD_PORT",
            ofp.OFPQOFC_BAD_QUEUE: "OFPQOFC_BAD_QUEUE",
            ofp.OFPQOFC_EPERM: "OFPQOFC_EPERM",
        },
    ),
    ofp.OFPET_SWITCH_CONFIG_FAILED: (
        "OFPET_SWITCH_CONFIG_FAILED",
        {
            ofp.OFPSCFC_BAD_FLAGS: "OFPSCFC_BAD_FLAGS",
            ofp.OFPSCFC_BAD_LEN: "OFPSCFC_BAD_LEN",
            ofp.OFPSCFC_EPERM: "OFPSCFC_EPERM",
        },
    ),
    ofp.OFPET_ROLE_REQUEST_FAILED: (
        "OFPET_ROLE_REQUEST_FAILED",
        {
            ofp.OFPRRFC_STALE: "OFPRRFC_STALE",
            ofp.OFPRRFC_UNSUP: "OFPRRFC_UNSUP",
            ofp.OFPRRFC_BAD_ROLE: "OFPRRFC_BAD_ROLE",
        },
    ),
    ofp.OFPET_METER_MOD_FAILED: (
        "OFPET_METER_MOD_FAILED",
        {
            ofp.OFPMMFC_UNKNOWN: "OFPMMFC_UNKNOWN",
            ofp.OFPMMFC_METER_EXISTS: "OFPMMFC_METER_EXISTS",
            ofp.OFPMMFC_INVALID_METER: "OFPMMFC_INVALID_METER",
            ofp.OFPMMFC_UNKNOWN_METER: "OFPMMFC_UNKNOWN_METER",
            ofp.OFPMMFC_BAD_COMMAND: "OFPMMFC_BAD_COMMAND",
            ofp.OFPMMFC_BAD_FLAGS: "OFPMMFC_BAD_FLAGS",
            ofp.OFPMMFC_BAD_RATE: "OFPMMFC_BAD_RATE",
            ofp.OFPMMFC_BAD_BURST: "OFPMMFC_BAD_BURST",
            ofp.OFPMMFC_BAD_BAND: "OFPMMFC_BAD_BAND",
            ofp.OFPMMFC_BAD_BAND_VALUE: "OFPMMFC_BAD_BAND_VALUE",
            ofp.OFPMMFC_OUT_OF_METERS: "OFPMMFC_OUT_OF_METERS",
            ofp.OFPMMFC_OUT_OF_BANDS: "OFPMMFC_OUT_OF_BANDS",
        },
    ),
    ofp.OFPET_TABLE_FEATURES_FAILED: (
        "OFPET_TABLE_FEATURES_FAILED",
        {
            ofp.OFPTFFC_BAD_TABLE: "OFPTFFC_BAD_TABLE",
            ofp.OFPTFFC_BAD_METADATA: "OFPTFFC_BAD_METADATA",
            ofp.OFPTFFC_BAD_TYPE: "OFPTFFC_BAD_TYPE",
            ofp.OFPTFFC_BAD_LEN: "OFPTFFC_BAD_LEN",
            ofp.OFPTFFC_BAD_ARGUMENT: "OFPTFFC_BAD_ARGUMENT",
            ofp.OFPTFFC_EPERM: "OFPTFFC_EPERM",
        },
    ),
    ofp.OFPET_EXPERIMENTER: ("OFPET_EXPERIMENTER", {}),
}


[docs] def ignore_port(port_num): """Return True if FAUCET should ignore this port. Args: port_num (int): switch port. Returns: bool: True if FAUCET should ignore this port. """ # special case OFPP_LOCAL to allow FAUCET to manage switch admin interface. if port_num in (ofp.OFPP_LOCAL, ofp.OFPP_IN_PORT): return False # 0xF0000000 and up are not physical ports. return port_num > 0xF0000000
[docs] def port_status_from_state(state): """Return True if OFPPS_LINK_DOWN is not set.""" return not state & ofp.OFPPS_LINK_DOWN
[docs] def is_table_features_req(ofmsg): """Return True if flow message is a TFM req. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a TFM req. """ return isinstance(ofmsg, parser.OFPTableFeaturesStatsRequest)
[docs] def is_flowmod(ofmsg): """Return True if flow message is a FlowMod. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a FlowMod """ return isinstance(ofmsg, parser.OFPFlowMod)
[docs] def is_flowaddmod(ofmsg): """Return True if flow message is a FlowMod, add or modify. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a FlowMod, add or modify. """ return isinstance(ofmsg, parser.OFPFlowMod) and ofmsg.command in ( ofp.OFPFC_ADD, ofp.OFPFC_MODIFY, ofp.OFPFC_MODIFY_STRICT, )
[docs] def is_groupmod(ofmsg): """Return True if OF message is a GroupMod. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a GroupMod """ return isinstance(ofmsg, parser.OFPGroupMod)
[docs] def is_metermod(ofmsg): """Return True if OF message is a MeterMod. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a MeterMod """ return isinstance(ofmsg, parser.OFPMeterMod)
[docs] def is_packetout(ofmsg): """Return True if OF message is a PacketOut Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a PacketOut """ return isinstance(ofmsg, parser.OFPPacketOut)
[docs] def is_output(ofmsg): """Return True if flow message is an action output message. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a OFPActionOutput. """ return isinstance(ofmsg, parser.OFPActionOutput)
[docs] def is_flowdel(ofmsg): """Return True if flow message is a FlowMod and a delete. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a FlowMod delete/strict. """ return is_flowmod(ofmsg) and ofmsg.command in ( ofp.OFPFC_DELETE, ofp.OFPFC_DELETE_STRICT, )
[docs] def is_groupdel(ofmsg): """Return True if OF message is a GroupMod and command is delete. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a GroupMod delete """ if is_groupmod(ofmsg) and (ofmsg.command == ofp.OFPGC_DELETE): return True return False
[docs] def is_meterdel(ofmsg): """Return True if OF message is a MeterMod and command is delete. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a MeterMod delete """ if is_metermod(ofmsg) and (ofmsg.command == ofp.OFPMC_DELETE): return True return False
[docs] def is_groupadd(ofmsg): """Return True if OF message is a GroupMod and command is add. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a GroupMod add """ if is_groupmod(ofmsg) and (ofmsg.command == ofp.OFPGC_ADD): return True return False
[docs] def is_meteradd(ofmsg): """Return True if OF message is a MeterMod and command is add. Args: ofmsg: ryu.ofproto.ofproto_v1_3_parser message. Returns: bool: True if is a MeterMod add """ if is_metermod(ofmsg) and (ofmsg.command == ofp.OFPMC_ADD): return True return False
[docs] def is_apply_actions(instruction): """Return True if an apply action. Args: instruction: OpenFlow instruction. Returns: bool: True if an apply action. """ return ( isinstance(instruction, parser.OFPInstructionActions) and instruction.type == ofp.OFPIT_APPLY_ACTIONS )
[docs] def is_meter(instruction): """Return True if a meter. Args: instruction: OpenFlow instruction. Returns: bool: True if a meter. """ return isinstance(instruction, parser.OFPInstructionMeter)
[docs] def is_set_field(action): return isinstance(action, parser.OFPActionSetField)
[docs] def is_ct(action): return isinstance(action, parser.NXActionCT) # pylint: disable=no-member
[docs] def apply_meter(meter_id): """Return instruction to apply a meter.""" return parser.OFPInstructionMeter(meter_id, ofp.OFPIT_METER)
@functools.lru_cache() def _apply_actions(actions): return parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)
[docs] def apply_actions(actions): """Return instruction that applies action list. Args: actions (list): list of OpenFlow actions. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPInstruction: instruction of actions. """ return _apply_actions(tuple(actions))
[docs] @functools.lru_cache() def goto_table(table): """Return instruction to goto table. Args: table (ValveTable): table to goto. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPInstruction: goto instruction. """ return parser.OFPInstructionGotoTable(table.table_id)
[docs] @functools.lru_cache() def goto_table_id(table_id): """Return instruction to goto table by table ID. Args: table (int): table by ID to goto. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPInstruction: goto instruction. """ return parser.OFPInstructionGotoTable(table_id)
[docs] def metadata_goto_table(metadata, mask, table): """Return instructions to write metadata and goto table. Args: metadata (int): metadata to write to packet maks (int): mask to apply to metadata table (ValveTable): table to goto. Returns: list of OFPInstructions""" return [ parser.OFPInstructionWriteMetadata(metadata, mask), parser.OFPInstructionGotoTable(table.table_id), ]
[docs] @functools.lru_cache() def set_field(**kwds): """Return action to set any field. Args: kwds (dict): exactly one field to set Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField: set field action. """ return parser.OFPActionSetField(**kwds)
[docs] def vid_present(vid): """Return VLAN VID with VID_PRESENT flag set. Args: vid (int): VLAN VID Returns: int: VLAN VID with VID_PRESENT. """ return vid | ofp.OFPVID_PRESENT
[docs] def devid_present(vid): """Return VLAN VID without VID_PRESENT flag set. Args: vid (int): VLAN VID with VID_PRESENT. Returns: int: VLAN VID. """ return vid ^ ofp.OFPVID_PRESENT
[docs] @functools.lru_cache(maxsize=1024) def push_vlan_act(table, vlan_vid, eth_type=ether.ETH_TYPE_8021Q): """Return OpenFlow action list to push Ethernet 802.1Q header with VLAN VID. Args: vid (int): VLAN VID Returns: list: actions to push 802.1Q header with VLAN VID set. """ return [ parser.OFPActionPushVlan(eth_type), table.set_vlan_vid(vlan_vid), ]
[docs] @functools.lru_cache() def dec_ip_ttl(): """Return OpenFlow action to decrement IP TTL. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionDecNwTtl: decrement IP TTL. """ return parser.OFPActionDecNwTtl()
[docs] @functools.lru_cache(maxsize=1024) def pop_vlan(): """Return OpenFlow action to pop outermost Ethernet 802.1Q VLAN header. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionPopVlan: Pop VLAN. """ return parser.OFPActionPopVlan()
[docs] def ct(**kwds): # pylint: disable=invalid-name """Return connection tracker action. Args: kwds (dict): exactly one connection tracker action. Returns: ryu.ofproto.nx_actions.NXActionCT: connection tracker action. """ return parser.NXActionCT(**kwds) # pylint: disable=no-member
[docs] def ct_clear(): """Return clear connection tracker state action. Args: kwds (dict): exactly one clear connection tracker state action. Returns: ryu.ofproto.nx_actions.NXActionCTClear: clear connection tracker state action. """ return parser.NXActionCTClear() # pylint: disable=no-member
[docs] def ct_nat(**kwds): """Return network address translation connection tracker action. Args: kwds (dict): exactly one network address translation connection tracker action. Returns: ryu.ofproto.nx_actions.NXActionNAT: network address translation connection tracker action. """ return parser.NXActionNAT(**kwds) # pylint: disable=no-member
[docs] @functools.lru_cache(maxsize=1024) def output_port(port_num, max_len=0): """Return OpenFlow action to output to a port. Args: port_num (int): port to output to. max_len (int): maximum length of packet to output (default no maximum). Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: output to port action. """ return parser.OFPActionOutput(port_num, max_len=max_len)
[docs] def ports_from_output_port_acts(output_port_acts): """Return unique port numbers from OFPActionOutput actions. Args: list of ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: output to port actions. Returns: set of port number ints. """ return {output_port_act.port for output_port_act in output_port_acts}
[docs] def dedupe_output_port_acts(output_port_acts): """Deduplicate parser.OFPActionOutputs (because Ryu doesn't define __eq__). Args: list of ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: output to port actions. Returns: list of ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: output to port actions. """ output_ports = ports_from_output_port_acts(output_port_acts) return [output_port(port) for port in sorted(output_ports)]
[docs] @functools.lru_cache(maxsize=1024) def output_non_output_actions(flood_acts): """Split output actions into deduped actions, output ports, and non-output port actions. Args: list of ryu.ofproto.ofproto_v1_3_parser.OFPActions: flood actions. Returns: set of deduped actions, output ports, and non-output actions. """ output_ports = set() all_nonoutput_actions = set() deduped_acts = [] # avoid dedupe_ofmsgs() here, as it's expensive - most of the time we are comparing # port numbers as integers which is much cheaper. for act in flood_acts: if is_output(act): if act.port in output_ports: continue output_ports.add(act.port) else: str_act = str(act) if str_act in all_nonoutput_actions: continue all_nonoutput_actions.add(str_act) deduped_acts.append(act) nonoutput_actions = all_nonoutput_actions - set([str(pop_vlan())]) return (deduped_acts, output_ports, nonoutput_actions)
[docs] @functools.lru_cache() def output_in_port(): """Return OpenFlow action to output out input port. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput. """ return output_port(OFP_IN_PORT)
[docs] @functools.lru_cache() def output_controller(max_len=MAX_PACKET_IN_BYTES): """Return OpenFlow action to packet in to the controller. Args: max_len (int): max number of bytes from packet to output. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: packet in action. """ return output_port(ofp.OFPP_CONTROLLER, max_len)
[docs] def packetouts(port_nums, data): """Return OpenFlow action to multiply packet out to dataplane from controller. Args: port_num (list): ints, ports to output to. data (str): raw packet to output. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: packet out action. """ random.shuffle(port_nums) return parser.OFPPacketOut( datapath=None, buffer_id=ofp.OFP_NO_BUFFER, in_port=ofp.OFPP_CONTROLLER, actions=[output_port(port_num) for port_num in port_nums], data=data, )
[docs] @functools.lru_cache() def packetout(port_num, data): """Return OpenFlow action to packet out to dataplane from controller. Args: port_num (int): port to output to. data (str): raw packet to output. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionOutput: packet out action. """ return packetouts([port_num], data)
[docs] @functools.lru_cache() def barrier(): """Return OpenFlow barrier request. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPBarrierRequest: barrier request. """ return parser.OFPBarrierRequest(None)
[docs] def table_features(body): return parser.OFPTableFeaturesStatsRequest(datapath=None, body=body)
[docs] def match(match_fields): """Return OpenFlow matches from dict. Args: match_fields (dict): match fields and values. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPMatch: matches. """ return parser.OFPMatch(**match_fields)
[docs] @functools.lru_cache() def valve_match_vid(value): return to_match_vid(value, ofp.OFPVID_PRESENT)
MATCH_FIELDS = { # See 7.2.3.7 Flow Match Fields (OF 1.3.5) "in_port": OFCtlUtil(ofp).ofp_port_from_user, "in_phy_port": str_to_int, "metadata": to_match_masked_int, "eth_dst": to_match_eth, "eth_src": to_match_eth, "eth_type": str_to_int, "vlan_vid": valve_match_vid, "vlan_pcp": str_to_int, "ip_dscp": str_to_int, "ip_ecn": str_to_int, "ip_proto": str_to_int, "ipv4_src": to_match_ip, "ipv4_dst": to_match_ip, "tcp_src": to_match_masked_int, "tcp_dst": to_match_masked_int, "udp_src": to_match_masked_int, "udp_dst": to_match_masked_int, "sctp_src": to_match_masked_int, "sctp_dst": to_match_masked_int, "icmpv4_type": str_to_int, "icmpv4_code": str_to_int, "arp_op": str_to_int, "arp_spa": to_match_ip, "arp_tpa": to_match_ip, "arp_sha": to_match_eth, "arp_tha": to_match_eth, "ipv6_src": to_match_ip, "ipv6_dst": to_match_ip, "ipv6_flabel": str_to_int, "icmpv6_type": str_to_int, "icmpv6_code": str_to_int, "ipv6_nd_target": to_match_ip, "ipv6_nd_sll": to_match_eth, "ipv6_nd_tll": to_match_eth, "mpls_label": str_to_int, "mpls_tc": str_to_int, "mpls_bos": str_to_int, "pbb_isid": to_match_masked_int, "tunnel_id": to_match_masked_int, "ipv6_exthdr": to_match_masked_int, # Nicira extensions, see ovs-fields(7) "eth_type_nxm": str_to_int, "ip_proto_nxm": str_to_int, "nw_ttl": str_to_int, "ct_state": to_match_masked_int, "ct_zone": str_to_int, "ct_mark": to_match_masked_int, "ct_label": to_match_masked_int, }
[docs] def match_from_dict(match_dict): """Parse a match dict into a OFPMatch object""" kwargs = {} for of_match, field in match_dict.items(): of_match = OLD_MATCH_FIELDS.get(of_match, of_match) test_config_condition( of_match not in MATCH_FIELDS, "Unknown match field: %s" % of_match ) try: encoded_field = MATCH_FIELDS[of_match](field) except TypeError as type_error: raise InvalidConfigError( "%s cannot be type %s" % (of_match, type(field)) ) from type_error kwargs[of_match] = encoded_field return parser.OFPMatch(**kwargs)
def _match_ip_masked(ipa): if isinstance(ipa, (ipaddress.IPv4Network, ipaddress.IPv6Network)): return (str(ipa.network_address), str(ipa.netmask)) return (str(ipa.ip), str(ipa.netmask))
[docs] @functools.lru_cache(maxsize=1024) def build_match_dict( in_port=None, vlan=None, eth_type=None, eth_src=None, eth_dst=None, eth_dst_mask=None, icmpv6_type=None, nw_proto=None, nw_dst=None, metadata=None, metadata_mask=None, vlan_pcp=None, udp_src=None, udp_dst=None, ): match_dict = {} if in_port is not None: match_dict["in_port"] = in_port if vlan is not None: if isinstance(vlan, int): vid = vlan else: vid = vlan.vid if vid == ofp.OFPVID_NONE: match_dict["vlan_vid"] = int(ofp.OFPVID_NONE) elif vid == ofp.OFPVID_PRESENT: match_dict["vlan_vid"] = (ofp.OFPVID_PRESENT, ofp.OFPVID_PRESENT) else: match_dict["vlan_vid"] = vid_present(vid) if eth_src is not None: match_dict["eth_src"] = eth_src if eth_dst is not None: if eth_dst_mask is not None: match_dict["eth_dst"] = (eth_dst, eth_dst_mask) else: match_dict["eth_dst"] = eth_dst if nw_proto is not None: match_dict["ip_proto"] = nw_proto if udp_dst is not None: match_dict["udp_dst"] = udp_dst if udp_src is not None: match_dict["udp_src"] = udp_src if icmpv6_type is not None: match_dict["icmpv6_type"] = icmpv6_type if nw_dst is not None: nw_dst_masked = _match_ip_masked(nw_dst) if eth_type == ether.ETH_TYPE_ARP: match_dict["arp_tpa"] = str(nw_dst.ip) elif eth_type == ether.ETH_TYPE_IP: match_dict["ipv4_dst"] = nw_dst_masked else: match_dict["ipv6_dst"] = nw_dst_masked if eth_type is not None: match_dict["eth_type"] = eth_type if metadata is not None: if metadata_mask is not None: match_dict["metadata"] = (metadata, metadata_mask) else: match_dict["metadata"] = metadata if vlan_pcp is not None: match_dict["vlan_pcp"] = vlan_pcp return match_dict
[docs] @functools.lru_cache() def flowmod( cookie, command, table_id, priority, out_port, out_group, match_fields, inst, hard_timeout, idle_timeout, flags=0, ): return parser.OFPFlowMod( datapath=None, cookie=cookie, command=command, table_id=table_id, priority=priority, out_port=out_port, out_group=out_group, match=match_fields, instructions=inst, hard_timeout=hard_timeout, idle_timeout=idle_timeout, flags=flags, )
[docs] class NullRyuDatapath: """Placeholder Ryu Datapath.""" ofproto = ofp
[docs] @functools.lru_cache() def verify_flowmod(flowmod_msg): """Verify flowmod can be serialized.""" flowmod_msg.datapath = NullRyuDatapath() # Must be non-zero. flowmod_msg.set_xid(1) flowmod_msg.serialize()
[docs] def group_act(group_id): """Return an action to run a group.""" return parser.OFPActionGroup(group_id)
[docs] def bucket(weight=0, watch_port=ofp.OFPP_ANY, watch_group=ofp.OFPG_ANY, actions=None): """Return a group action bucket with provided actions.""" return parser.OFPBucket( weight=weight, watch_port=watch_port, watch_group=watch_group, actions=actions )
[docs] def build_group_flood_buckets(vlan_flood_acts): """Return a list of group buckets to implement flooding on a VLAN.""" buckets = [] non_outputs = [] for act in vlan_flood_acts: if is_output(act): buckets.append(bucket(actions=non_outputs + [act])) else: non_outputs.append(act) return buckets
[docs] def groupdel(datapath=None, group_id=ofp.OFPG_ALL): """Delete a group (default all groups).""" return parser.OFPGroupMod(datapath, ofp.OFPGC_DELETE, 0, group_id)
[docs] def groupadd(datapath=None, type_=ofp.OFPGT_ALL, group_id=0, buckets=None): """Add a group.""" return [ groupdel(datapath=datapath, group_id=group_id), parser.OFPGroupMod(datapath, ofp.OFPGC_ADD, type_, group_id, buckets), ]
[docs] def groupadd_ff(datapath=None, group_id=0, buckets=None): """Add a fast failover group.""" return groupadd(datapath, type_=ofp.OFPGT_FF, group_id=group_id, buckets=buckets)
[docs] def meterdel(datapath=None, meter_id=ofp.OFPM_ALL): """Delete a meter (default all meters).""" return parser.OFPMeterMod(datapath, ofp.OFPMC_DELETE, 0, meter_id)
[docs] def meteradd(meter_conf, command=ofp.OFPMC_ADD): """Add a meter based on YAML configuration.""" class NoopDP: """Fake DP to be able to use ofctl to parse meter config.""" id = 0 msg = None ofproto = ofp ofproto_parser = parser def send_msg(self, msg): """Save msg only.""" self.msg = msg @staticmethod def set_xid(msg): """Clear msg XID.""" msg.xid = 0 noop_dp = NoopDP() ofctl.mod_meter_entry(noop_dp, meter_conf, command) noop_dp.msg.xid = None noop_dp.msg.datapath = None return noop_dp.msg
[docs] def controller_pps_meteradd(datapath=None, pps=0): """Add a PPS meter towards controller.""" return parser.OFPMeterMod( datapath=datapath, command=ofp.OFPMC_ADD, flags=ofp.OFPMF_PKTPS, meter_id=ofp.OFPM_CONTROLLER, bands=[parser.OFPMeterBandDrop(rate=pps)], )
[docs] def controller_pps_meterdel(datapath=None): """Delete a PPS meter towards controller.""" return parser.OFPMeterMod( datapath=datapath, command=ofp.OFPMC_DELETE, flags=ofp.OFPMF_PKTPS, meter_id=ofp.OFPM_CONTROLLER, )
[docs] def slowpath_pps_meteradd(datapath=None, pps=0): """Add a PPS meter towards controller.""" return parser.OFPMeterMod( datapath=datapath, command=ofp.OFPMC_ADD, flags=ofp.OFPMF_PKTPS, meter_id=ofp.OFPM_SLOWPATH, bands=[parser.OFPMeterBandDrop(rate=pps)], )
[docs] def slowpath_pps_meterdel(datapath=None): """Delete a PPS meter towards controller.""" return parser.OFPMeterMod( datapath=datapath, command=ofp.OFPMC_DELETE, flags=ofp.OFPMF_PKTPS, meter_id=ofp.OFPM_SLOWPATH, )
[docs] def is_global_flowdel(ofmsg): """Is a delete of all flows in all tables.""" return ( is_flowdel(ofmsg) and ofmsg.table_id == ofp.OFPTT_ALL and not ofmsg.match.items() )
[docs] def is_global_groupdel(ofmsg): """Is a delete of all groups.""" return is_groupdel(ofmsg) and ofmsg.group_id == ofp.OFPG_ALL
[docs] def is_global_meterdel(ofmsg): """Is a delete of all meters.""" return is_meterdel(ofmsg) and ofmsg.meter_id == ofp.OFPM_ALL
# We can tell right away what kind of OF messages these are. _MSG_KINDS_TYPES = { parser.OFPPacketOut: "packetout", parser.OFPTableFeaturesStatsRequest: "tfm", parser.OFPSetConfig: "config", parser.OFPSetAsync: "config", parser.OFPDescStatsRequest: "config", } # We need to examine the OF message more closely to classify it. _MSG_KINDS = { parser.OFPFlowMod: ( ("deleteglobal", is_global_flowdel), ("delete", is_flowdel), ("flowaddmod", is_flowaddmod), ), parser.OFPGroupMod: ( ("deleteglobal", is_global_groupdel), ("delete", is_groupdel), ("groupadd", is_groupadd), ), parser.OFPMeterMod: ( ("deleteglobal", is_global_meterdel), ("delete", is_meterdel), ("meteradd", is_meteradd), ), } @functools.lru_cache() def _msg_kind(ofmsg): ofmsg_type = type(ofmsg) ofmsg_kind = _MSG_KINDS_TYPES.get(ofmsg_type, None) if ofmsg_kind: return ofmsg_kind kinds = _MSG_KINDS.get(ofmsg_type, None) if kinds: for kind, kind_func in kinds: if kind_func(ofmsg): return kind return "other" def _partition_ofmsgs(input_ofmsgs): """Partition input ofmsgs by kind.""" by_kind = {} for ofmsg in input_ofmsgs: by_kind.setdefault(_msg_kind(ofmsg), []).append(ofmsg) return by_kind def _flowmodkey(ofmsg): return (ofmsg.match, ofmsg.cookie, ofmsg.priority, ofmsg.table_id) def _none_flowmodkey(ofmsg): try: return _flowmodkey(ofmsg) except AttributeError: return None
[docs] def sort_flows(input_ofmsgs): """Sort flows in canonical order, descending table and priority.""" return sorted( input_ofmsgs, key=lambda ofmsg: ( getattr(ofmsg, "table_id", ofp.OFPTT_ALL), getattr(ofmsg, "priority", 2**16 + 1), ), reverse=True, )
[docs] def dedupe_ofmsgs(input_ofmsgs, random_order, flowkey): """Return deduplicated ofmsg list.""" # Built in comparison doesn't work until serialized() called # Can't use dict or json comparison as may be nested deduped_input_ofmsgs = {flowkey(ofmsg): ofmsg for ofmsg in input_ofmsgs} if random_order: ofmsgs = list(deduped_input_ofmsgs.values()) random.shuffle(ofmsgs) return ofmsgs return sort_flows(deduped_input_ofmsgs.values())
[docs] def dedupe_overlaps_ofmsgs(input_ofmsgs, random_order, flowkey): deduped_ofmsgs = dedupe_ofmsgs(input_ofmsgs, random_order, flowkey) ofmsgs_by_table = {} for ofmsg in deduped_ofmsgs: table_id = getattr(ofmsg, "table_id", None) ofmsgs_by_table.setdefault(table_id, []).append(ofmsg) all_table_ids = { table_id for table_id in ofmsgs_by_table if isinstance(table_id, int) } # If priority-less deletes across all tables are detected, then remove any # overlapping deletes (e.g. if a delete all tables vlan=100 is deleted, then remove # all other table-specific deletes that have vlan=100). if ofp.OFPTT_ALL in all_table_ids: overlap_matches = { tuple(ofmsg.match.items()) for ofmsg in ofmsgs_by_table[ofp.OFPTT_ALL] if not ofmsg.priority } table_ids = all_table_ids - {ofp.OFPTT_ALL} if overlap_matches and table_ids: for table_id in table_ids: for overlap_match in overlap_matches: overlap_match = set(overlap_match) ofmsgs_by_table[table_id] = [ ofmsg for ofmsg in ofmsgs_by_table[table_id] if not overlap_match.issubset(set(ofmsg.match.items())) ] nooverlaps_ofmsgs = [] for _, ofmsgs in sorted(ofmsgs_by_table.items(), reverse=True): nooverlaps_ofmsgs.extend(ofmsgs) return nooverlaps_ofmsgs return deduped_ofmsgs
[docs] def remove_overlap_ofmsgs(input_ofmsgs, overlap_input_ofmsgs): overlap_keys = {_none_flowmodkey(ofmsg) for ofmsg in overlap_input_ofmsgs} - {None} input_ofmsgs_without_overlaps = [] for ofmsg in input_ofmsgs: key = _none_flowmodkey(ofmsg) if key is not None and key in overlap_keys: continue input_ofmsgs_without_overlaps.append(ofmsg) return input_ofmsgs_without_overlaps
# kind, random_order, suggest_barrier, flowkey _OFMSG_ORDER = ( ("config", False, True, str, dedupe_ofmsgs), ("deleteglobal", False, True, str, dedupe_ofmsgs), ("delete", False, True, str, dedupe_overlaps_ofmsgs), ("tfm", False, True, str, dedupe_ofmsgs), ("groupadd", False, True, str, dedupe_ofmsgs), ("meteradd", False, True, str, dedupe_ofmsgs), ("flowaddmod", False, False, _flowmodkey, dedupe_ofmsgs), ("other", False, False, str, dedupe_ofmsgs), ("packetout", True, False, str, dedupe_ofmsgs), )
[docs] def valve_flowreorder(input_ofmsgs, use_barriers=True): """Reorder flows for better OFA performance.""" # Move all deletes to be first, and add one barrier, # while optionally randomizing order. Platforms that do # parallel delete will perform better and platforms that # don't will have at most only one barrier to deal with. output_ofmsgs = [] by_kind = _partition_ofmsgs(input_ofmsgs) # Suppress all other relevant deletes if a global delete is present. delete_global_ofmsgs = by_kind.get("deleteglobal", []) if delete_global_ofmsgs: global_types = {type(ofmsg) for ofmsg in delete_global_ofmsgs} new_delete = [ ofmsg for ofmsg in by_kind.get("delete", []) if type(ofmsg) not in global_types ] by_kind["delete"] = new_delete for kind, random_order, _suggest_barrier, flowkey, dedupe_func in _OFMSG_ORDER: ofmsgs = dedupe_func(by_kind.get(kind, []), random_order, flowkey) if ofmsgs: by_kind[kind] = ofmsgs deletes = by_kind.get("delete", None) addmod = by_kind.get("flowaddmod", None) if deletes and addmod: by_kind["delete"] = remove_overlap_ofmsgs(deletes, addmod) for kind, _random_order, suggest_barrier, _flowkey, dedupe_func in _OFMSG_ORDER: ofmsgs = by_kind.get(kind, []) if ofmsgs: output_ofmsgs.extend(ofmsgs) if use_barriers and suggest_barrier: output_ofmsgs.append(barrier()) return output_ofmsgs
[docs] def flood_tagged_port_outputs(ports, in_port=None, exclude_ports=None): """Return list of actions necessary to flood to list of tagged ports.""" flood_acts = [] in_port_mirror_output_ports = {} if in_port is not None: in_port_mirror_output_ports = ports_from_output_port_acts( in_port.mirror_actions() ) if ports: for port in ports: if in_port is not None and port == in_port: if in_port.hairpin: flood_acts.append(output_in_port()) continue if exclude_ports and port in exclude_ports: continue flood_acts.append(output_port(port.number)) # Only mirror if different mirror actions to in_port # (already will be mirrored on input). mirror_actions = port.mirror_actions() mirror_output_ports = ports_from_output_port_acts(mirror_actions) if in_port is None or in_port_mirror_output_ports != mirror_output_ports: flood_acts.extend(mirror_actions) return dedupe_output_port_acts(flood_acts)
[docs] def flood_untagged_port_outputs(ports, in_port=None, exclude_ports=None): """Return list of actions necessary to flood to list of untagged ports.""" flood_acts = flood_tagged_port_outputs( ports, in_port=in_port, exclude_ports=exclude_ports ) if flood_acts: flood_acts = [pop_vlan()] + flood_acts return flood_acts
[docs] def flood_port_outputs(tagged_ports, untagged_ports, in_port=None, exclude_ports=None): """Return actions for both tagged and untagged ports.""" return flood_tagged_port_outputs( tagged_ports, in_port, exclude_ports ) + flood_untagged_port_outputs(untagged_ports, in_port, exclude_ports)
[docs] def faucet_config(datapath=None): """Return switch config for FAUCET.""" return parser.OFPSetConfig(datapath, ofp.OFPC_FRAG_NORMAL, 0)
[docs] def faucet_async( datapath=None, notify_flow_removed=False, packet_in=True, port_status=True ): """Return async message config for FAUCET/Gauge""" packet_in_mask = 0 if packet_in: packet_in_mask = 1 << ofp.OFPR_ACTION | 1 << ofp.OFPR_INVALID_TTL port_status_mask = 0 if port_status: port_status_mask = ( 1 << ofp.OFPPR_ADD | 1 << ofp.OFPPR_DELETE | 1 << ofp.OFPPR_MODIFY ) flow_removed_mask = 0 if notify_flow_removed: flow_removed_mask = 1 << ofp.OFPRR_IDLE_TIMEOUT | 1 << ofp.OFPRR_HARD_TIMEOUT return parser.OFPSetAsync( datapath, [packet_in_mask, packet_in_mask], [port_status_mask, port_status_mask], [flow_removed_mask, flow_removed_mask], )
[docs] def desc_stats_request(datapath=None): """Query switch description.""" return parser.OFPDescStatsRequest(datapath, 0)