justuser-31/JustOS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
02e73b8cd9
JustOS/linux-6.13/tools/testing/selftests/net/openvswitch/ovs-dpctl.py

2776 lines
89 KiB
Python
Raw Normal View History

up
2025-01-24 14:00:19 +00:00
#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0
# Controls the openvswitch module. Part of the kselftest suite, but
# can be used for some diagnostic purpose as well.
import argparse
import errno
import ipaddress
import logging
import math
import multiprocessing
import re
import socket
import struct
import sys
import time
import types
import uuid
try:
from pyroute2 import NDB
from pyroute2.netlink import NLA_F_NESTED
from pyroute2.netlink import NLM_F_ACK
from pyroute2.netlink import NLM_F_DUMP
from pyroute2.netlink import NLM_F_REQUEST
from pyroute2.netlink import genlmsg
from pyroute2.netlink import nla
from pyroute2.netlink import nlmsg_atoms
from pyroute2.netlink.event import EventSocket
from pyroute2.netlink.exceptions import NetlinkError
from pyroute2.netlink.generic import GenericNetlinkSocket
from pyroute2.netlink.nlsocket import Marshal
import pyroute2
import pyroute2.iproute
except ModuleNotFoundError:
print("Need to install the python pyroute2 package >= 0.6.")
sys.exit(1)
OVS_DATAPATH_FAMILY = "ovs_datapath"
OVS_VPORT_FAMILY = "ovs_vport"
OVS_FLOW_FAMILY = "ovs_flow"
OVS_PACKET_FAMILY = "ovs_packet"
OVS_METER_FAMILY = "ovs_meter"
OVS_CT_LIMIT_FAMILY = "ovs_ct_limit"
OVS_DATAPATH_VERSION = 2
OVS_DP_CMD_NEW = 1
OVS_DP_CMD_DEL = 2
OVS_DP_CMD_GET = 3
OVS_DP_CMD_SET = 4
OVS_VPORT_CMD_NEW = 1
OVS_VPORT_CMD_DEL = 2
OVS_VPORT_CMD_GET = 3
OVS_VPORT_CMD_SET = 4
OVS_FLOW_CMD_NEW = 1
OVS_FLOW_CMD_DEL = 2
OVS_FLOW_CMD_GET = 3
OVS_FLOW_CMD_SET = 4
UINT32_MAX = 0xFFFFFFFF
def macstr(mac):
outstr = ":".join(["%02X" % i for i in mac])
return outstr
def strcspn(str1, str2):
tot = 0
for char in str1:
if str2.find(char) != -1:
return tot
tot += 1
return tot
def strspn(str1, str2):
tot = 0
for char in str1:
if str2.find(char) == -1:
return tot
tot += 1
return tot
def intparse(statestr, defmask="0xffffffff"):
totalparse = strspn(statestr, "0123456789abcdefABCDEFx/")
# scan until "/"
count = strspn(statestr, "x0123456789abcdefABCDEF")
firstnum = statestr[:count]
if firstnum[-1] == "/":
firstnum = firstnum[:-1]
k = int(firstnum, 0)
m = None
if defmask is not None:
secondnum = defmask
if statestr[count] == "/":
secondnum = statestr[count + 1 :] # this is wrong...
m = int(secondnum, 0)
return statestr[totalparse + 1 :], k, m
def parse_flags(flag_str, flag_vals):
bitResult = 0
maskResult = 0
if len(flag_str) == 0:
return flag_str, bitResult, maskResult
if flag_str[0].isdigit():
idx = 0
while flag_str[idx].isdigit() or flag_str[idx] == "x":
idx += 1
digits = flag_str[:idx]
flag_str = flag_str[idx:]
bitResult = int(digits, 0)
maskResult = int(digits, 0)
while len(flag_str) > 0 and (flag_str[0] == "+" or flag_str[0] == "-"):
if flag_str[0] == "+":
setFlag = True
elif flag_str[0] == "-":
setFlag = False
flag_str = flag_str[1:]
flag_len = 0
while (
flag_str[flag_len] != "+"
and flag_str[flag_len] != "-"
and flag_str[flag_len] != ","
and flag_str[flag_len] != ")"
):
flag_len += 1
flag = flag_str[0:flag_len]
if flag in flag_vals:
if maskResult & flag_vals[flag]:
raise KeyError(
"Flag %s set once, cannot be set in multiples" % flag
)
if setFlag:
bitResult |= flag_vals[flag]
maskResult |= flag_vals[flag]
else:
raise KeyError("Missing flag value: %s" % flag)
flag_str = flag_str[flag_len:]
return flag_str, bitResult, maskResult
def parse_ct_state(statestr):
ct_flags = {
"new": 1 << 0,
"est": 1 << 1,
"rel": 1 << 2,
"rpl": 1 << 3,
"inv": 1 << 4,
"trk": 1 << 5,
"snat": 1 << 6,
"dnat": 1 << 7,
}
return parse_flags(statestr, ct_flags)
def convert_mac(data):
def to_bytes(mac):
mac_split = mac.split(":")
ret = bytearray([int(i, 16) for i in mac_split])
return bytes(ret)
mac_str, _, mask_str = data.partition('/')
if not mac_str:
mac_str = mask_str = "00:00:00:00:00:00"
elif not mask_str:
mask_str = "FF:FF:FF:FF:FF:FF"
return to_bytes(mac_str), to_bytes(mask_str)
def convert_ipv4(data):
ip, _, mask = data.partition('/')
if not ip:
ip = mask = 0
elif not mask:
mask = 0xFFFFFFFF
elif mask.isdigit():
mask = (0xFFFFFFFF << (32 - int(mask))) & 0xFFFFFFFF
return int(ipaddress.IPv4Address(ip)), int(ipaddress.IPv4Address(mask))
def convert_ipv6(data):
ip, _, mask = data.partition('/')
if not ip:
ip = mask = 0
elif not mask:
mask = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
elif mask.isdigit():
mask = ipaddress.IPv6Network("::/" + mask).hostmask
return ipaddress.IPv6Address(ip).packed, ipaddress.IPv6Address(mask).packed
def convert_int(size):
def convert_int_sized(data):
value, _, mask = data.partition('/')
if not value:
return 0, 0
elif not mask:
return int(value, 0), pow(2, size) - 1
else:
return int(value, 0), int(mask, 0)
return convert_int_sized
def parse_starts_block(block_str, scanstr, returnskipped, scanregex=False):
if scanregex:
m = re.search(scanstr, block_str)
if m is None:
if returnskipped:
return block_str
return False
if returnskipped:
block_str = block_str[len(m.group(0)) :]
return block_str
return True
if block_str.startswith(scanstr):
if returnskipped:
block_str = block_str[len(scanstr) :]
else:
return True
if returnskipped:
return block_str
return False
def parse_extract_field(
block_str, fieldstr, scanfmt, convert, masked=False, defval=None
):
if fieldstr and not block_str.startswith(fieldstr):
return block_str, defval
if fieldstr:
str_skiplen = len(fieldstr)
str_skipped = block_str[str_skiplen:]
if str_skiplen == 0:
return str_skipped, defval
else:
str_skiplen = 0
str_skipped = block_str
m = re.search(scanfmt, str_skipped)
if m is None:
raise ValueError("Bad fmt string")
data = m.group(0)
if convert:
data = convert(m.group(0))
str_skipped = str_skipped[len(m.group(0)) :]
if masked:
if str_skipped[0] == "/":
raise ValueError("Masking support TBD...")
str_skipped = str_skipped[strspn(str_skipped, ", ") :]
return str_skipped, data
def parse_attrs(actstr, attr_desc):
"""Parses the given action string and returns a list of netlink
attributes based on a list of attribute descriptions.
Each element in the attribute description list is a tuple such as:
(name, attr_name, parse_func)
where:
name: is the string representing the attribute
attr_name: is the name of the attribute as defined in the uAPI.
parse_func: is a callable accepting a string and returning either
a single object (the parsed attribute value) or a tuple of
two values (the parsed attribute value and the remaining string)
Returns a list of attributes and the remaining string.
"""
def parse_attr(actstr, key, func):
actstr = actstr[len(key) :]
if not func:
return None, actstr
delim = actstr[0]
actstr = actstr[1:]
if delim == "=":
pos = strcspn(actstr, ",)")
ret = func(actstr[:pos])
else:
ret = func(actstr)
if isinstance(ret, tuple):
(datum, actstr) = ret
else:
datum = ret
actstr = actstr[strcspn(actstr, ",)"):]
if delim == "(":
if not actstr or actstr[0] != ")":
raise ValueError("Action contains unbalanced parentheses")
actstr = actstr[1:]
actstr = actstr[strspn(actstr, ", ") :]
return datum, actstr
attrs = []
attr_desc = list(attr_desc)
while actstr and actstr[0] != ")" and attr_desc:
found = False
for i, (key, attr, func) in enumerate(attr_desc):
if actstr.startswith(key):
datum, actstr = parse_attr(actstr, key, func)
attrs.append([attr, datum])
found = True
del attr_desc[i]
if not found:
raise ValueError("Unknown attribute: '%s'" % actstr)
actstr = actstr[strspn(actstr, ", ") :]
if actstr[0] != ")":
raise ValueError("Action string contains extra garbage or has "
"unbalanced parenthesis: '%s'" % actstr)
return attrs, actstr[1:]
class ovs_dp_msg(genlmsg):
# include the OVS version
# We need a custom header rather than just being able to rely on
# genlmsg because fields ends up not expressing everything correctly
# if we use the canonical example of setting fields = (('customfield',),)
fields = genlmsg.fields + (("dpifindex", "I"),)
class ovsactions(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_ACTION_ATTR_UNSPEC", "none"),
("OVS_ACTION_ATTR_OUTPUT", "uint32"),
("OVS_ACTION_ATTR_USERSPACE", "userspace"),
("OVS_ACTION_ATTR_SET", "ovskey"),
("OVS_ACTION_ATTR_PUSH_VLAN", "none"),
("OVS_ACTION_ATTR_POP_VLAN", "flag"),
("OVS_ACTION_ATTR_SAMPLE", "sample"),
("OVS_ACTION_ATTR_RECIRC", "uint32"),
("OVS_ACTION_ATTR_HASH", "none"),
("OVS_ACTION_ATTR_PUSH_MPLS", "none"),
("OVS_ACTION_ATTR_POP_MPLS", "flag"),
("OVS_ACTION_ATTR_SET_MASKED", "ovskey"),
("OVS_ACTION_ATTR_CT", "ctact"),
("OVS_ACTION_ATTR_TRUNC", "uint32"),
("OVS_ACTION_ATTR_PUSH_ETH", "none"),
("OVS_ACTION_ATTR_POP_ETH", "flag"),
("OVS_ACTION_ATTR_CT_CLEAR", "flag"),
("OVS_ACTION_ATTR_PUSH_NSH", "none"),
("OVS_ACTION_ATTR_POP_NSH", "flag"),
("OVS_ACTION_ATTR_METER", "none"),
("OVS_ACTION_ATTR_CLONE", "recursive"),
("OVS_ACTION_ATTR_CHECK_PKT_LEN", "none"),
("OVS_ACTION_ATTR_ADD_MPLS", "none"),
("OVS_ACTION_ATTR_DEC_TTL", "none"),
("OVS_ACTION_ATTR_DROP", "uint32"),
("OVS_ACTION_ATTR_PSAMPLE", "psample"),
)
class psample(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_PSAMPLE_ATTR_UNSPEC", "none"),
("OVS_PSAMPLE_ATTR_GROUP", "uint32"),
("OVS_PSAMPLE_ATTR_COOKIE", "array(uint8)"),
)
def dpstr(self, more=False):
args = "group=%d" % self.get_attr("OVS_PSAMPLE_ATTR_GROUP")
cookie = self.get_attr("OVS_PSAMPLE_ATTR_COOKIE")
if cookie:
args += ",cookie(%s)" % \
"".join(format(x, "02x") for x in cookie)
return "psample(%s)" % args
def parse(self, actstr):
desc = (
("group", "OVS_PSAMPLE_ATTR_GROUP", int),
("cookie", "OVS_PSAMPLE_ATTR_COOKIE",
lambda x: list(bytearray.fromhex(x)))
)
attrs, actstr = parse_attrs(actstr, desc)
for attr in attrs:
self["attrs"].append(attr)
return actstr
class sample(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_SAMPLE_ATTR_UNSPEC", "none"),
("OVS_SAMPLE_ATTR_PROBABILITY", "uint32"),
("OVS_SAMPLE_ATTR_ACTIONS", "ovsactions"),
)
def dpstr(self, more=False):
args = []
args.append("sample={:.2f}%".format(
100 * self.get_attr("OVS_SAMPLE_ATTR_PROBABILITY") /
UINT32_MAX))
actions = self.get_attr("OVS_SAMPLE_ATTR_ACTIONS")
if actions:
args.append("actions(%s)" % actions.dpstr(more))
return "sample(%s)" % ",".join(args)
def parse(self, actstr):
def parse_nested_actions(actstr):
subacts = ovsactions()
parsed_len = subacts.parse(actstr)
return subacts, actstr[parsed_len :]
def percent_to_rate(percent):
percent = float(percent.strip('%'))
return int(math.floor(UINT32_MAX * (percent / 100.0) + .5))
desc = (
("sample", "OVS_SAMPLE_ATTR_PROBABILITY", percent_to_rate),
("actions", "OVS_SAMPLE_ATTR_ACTIONS", parse_nested_actions),
)
attrs, actstr = parse_attrs(actstr, desc)
for attr in attrs:
self["attrs"].append(attr)
return actstr
class ctact(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_CT_ATTR_NONE", "none"),
("OVS_CT_ATTR_COMMIT", "flag"),
("OVS_CT_ATTR_ZONE", "uint16"),
("OVS_CT_ATTR_MARK", "none"),
("OVS_CT_ATTR_LABELS", "none"),
("OVS_CT_ATTR_HELPER", "asciiz"),
("OVS_CT_ATTR_NAT", "natattr"),
("OVS_CT_ATTR_FORCE_COMMIT", "flag"),
("OVS_CT_ATTR_EVENTMASK", "uint32"),
("OVS_CT_ATTR_TIMEOUT", "asciiz"),
)
class natattr(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_NAT_ATTR_NONE", "none"),
("OVS_NAT_ATTR_SRC", "flag"),
("OVS_NAT_ATTR_DST", "flag"),
("OVS_NAT_ATTR_IP_MIN", "ipaddr"),
("OVS_NAT_ATTR_IP_MAX", "ipaddr"),
("OVS_NAT_ATTR_PROTO_MIN", "uint16"),
("OVS_NAT_ATTR_PROTO_MAX", "uint16"),
("OVS_NAT_ATTR_PERSISTENT", "flag"),
("OVS_NAT_ATTR_PROTO_HASH", "flag"),
("OVS_NAT_ATTR_PROTO_RANDOM", "flag"),
)
def dpstr(self, more=False):
print_str = "nat("
if self.get_attr("OVS_NAT_ATTR_SRC"):
print_str += "src"
elif self.get_attr("OVS_NAT_ATTR_DST"):
print_str += "dst"
else:
print_str += "XXX-unknown-nat"
if self.get_attr("OVS_NAT_ATTR_IP_MIN") or self.get_attr(
"OVS_NAT_ATTR_IP_MAX"
):
if self.get_attr("OVS_NAT_ATTR_IP_MIN"):
print_str += "=%s," % str(
self.get_attr("OVS_NAT_ATTR_IP_MIN")
)
if self.get_attr("OVS_NAT_ATTR_IP_MAX"):
print_str += "-%s," % str(
self.get_attr("OVS_NAT_ATTR_IP_MAX")
)
else:
print_str += ","
if self.get_attr("OVS_NAT_ATTR_PROTO_MIN"):
print_str += "proto_min=%d," % self.get_attr(
"OVS_NAT_ATTR_PROTO_MIN"
)
if self.get_attr("OVS_NAT_ATTR_PROTO_MAX"):
print_str += "proto_max=%d," % self.get_attr(
"OVS_NAT_ATTR_PROTO_MAX"
)
if self.get_attr("OVS_NAT_ATTR_PERSISTENT"):
print_str += "persistent,"
if self.get_attr("OVS_NAT_ATTR_HASH"):
print_str += "hash,"
if self.get_attr("OVS_NAT_ATTR_RANDOM"):
print_str += "random"
print_str += ")"
return print_str
def dpstr(self, more=False):
print_str = "ct("
if self.get_attr("OVS_CT_ATTR_COMMIT") is not None:
print_str += "commit,"
if self.get_attr("OVS_CT_ATTR_ZONE") is not None:
print_str += "zone=%d," % self.get_attr("OVS_CT_ATTR_ZONE")
if self.get_attr("OVS_CT_ATTR_HELPER") is not None:
print_str += "helper=%s," % self.get_attr("OVS_CT_ATTR_HELPER")
if self.get_attr("OVS_CT_ATTR_NAT") is not None:
print_str += self.get_attr("OVS_CT_ATTR_NAT").dpstr(more)
print_str += ","
if self.get_attr("OVS_CT_ATTR_FORCE_COMMIT") is not None:
print_str += "force,"
if self.get_attr("OVS_CT_ATTR_EVENTMASK") is not None:
print_str += "emask=0x%X," % self.get_attr(
"OVS_CT_ATTR_EVENTMASK"
)
if self.get_attr("OVS_CT_ATTR_TIMEOUT") is not None:
print_str += "timeout=%s" % self.get_attr(
"OVS_CT_ATTR_TIMEOUT"
)
print_str += ")"
return print_str
class userspace(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_USERSPACE_ATTR_UNUSED", "none"),
("OVS_USERSPACE_ATTR_PID", "uint32"),
("OVS_USERSPACE_ATTR_USERDATA", "array(uint8)"),
("OVS_USERSPACE_ATTR_EGRESS_TUN_PORT", "uint32"),
)
def dpstr(self, more=False):
print_str = "userspace("
if self.get_attr("OVS_USERSPACE_ATTR_PID") is not None:
print_str += "pid=%d," % self.get_attr(
"OVS_USERSPACE_ATTR_PID"
)
if self.get_attr("OVS_USERSPACE_ATTR_USERDATA") is not None:
print_str += "userdata="
for f in self.get_attr("OVS_USERSPACE_ATTR_USERDATA"):
print_str += "%x." % f
if self.get_attr("OVS_USERSPACE_ATTR_EGRESS_TUN_PORT") is not None:
print_str += "egress_tun_port=%d" % self.get_attr(
"OVS_USERSPACE_ATTR_EGRESS_TUN_PORT"
)
print_str += ")"
return print_str
def parse(self, actstr):
attrs_desc = (
("pid", "OVS_USERSPACE_ATTR_PID", int),
("userdata", "OVS_USERSPACE_ATTR_USERDATA",
lambda x: list(bytearray.fromhex(x))),
("egress_tun_port", "OVS_USERSPACE_ATTR_EGRESS_TUN_PORT", int)
)
attrs, actstr = parse_attrs(actstr, attrs_desc)
for attr in attrs:
self["attrs"].append(attr)
return actstr
def dpstr(self, more=False):
print_str = ""
for field in self["attrs"]:
if field[1] == "none" or self.get_attr(field[0]) is None:
continue
if print_str != "":
print_str += ","
if field[0] == "OVS_ACTION_ATTR_OUTPUT":
print_str += "%d" % int(self.get_attr(field[0]))
elif field[0] == "OVS_ACTION_ATTR_RECIRC":
print_str += "recirc(0x%x)" % int(self.get_attr(field[0]))
elif field[0] == "OVS_ACTION_ATTR_TRUNC":
print_str += "trunc(%d)" % int(self.get_attr(field[0]))
elif field[0] == "OVS_ACTION_ATTR_DROP":
print_str += "drop(%d)" % int(self.get_attr(field[0]))
elif field[0] == "OVS_ACTION_ATTR_CT_CLEAR":
print_str += "ct_clear"
elif field[0] == "OVS_ACTION_ATTR_POP_VLAN":
print_str += "pop_vlan"
elif field[0] == "OVS_ACTION_ATTR_POP_ETH":
print_str += "pop_eth"
elif field[0] == "OVS_ACTION_ATTR_POP_NSH":
print_str += "pop_nsh"
elif field[0] == "OVS_ACTION_ATTR_POP_MPLS":
print_str += "pop_mpls"
else:
datum = self.get_attr(field[0])
if field[0] == "OVS_ACTION_ATTR_CLONE":
print_str += "clone("
print_str += datum.dpstr(more)
print_str += ")"
elif field[0] == "OVS_ACTION_ATTR_SET" or \
field[0] == "OVS_ACTION_ATTR_SET_MASKED":
print_str += "set"
field = datum
mask = None
if field[0] == "OVS_ACTION_ATTR_SET_MASKED":
print_str += "_masked"
field = datum[0]
mask = datum[1]
print_str += "("
print_str += field.dpstr(mask, more)
print_str += ")"
else:
try:
print_str += datum.dpstr(more)
except:
print_str += "{ATTR: %s not decoded}" % field[0]
return print_str
def parse(self, actstr):
totallen = len(actstr)
while len(actstr) != 0:
parsed = False
parencount = 0
if actstr.startswith("drop"):
# If no reason is provided, the implicit drop is used (i.e no
# action). If some reason is given, an explicit action is used.
reason = None
if actstr.startswith("drop("):
parencount += 1
actstr, reason = parse_extract_field(
actstr,
"drop(",
r"([0-9]+)",
lambda x: int(x, 0),
False,
None,
)
if reason is not None:
self["attrs"].append(["OVS_ACTION_ATTR_DROP", reason])
parsed = True
else:
actstr = actstr[len("drop"): ]
return (totallen - len(actstr))
elif parse_starts_block(actstr, r"^(\d+)", False, True):
actstr, output = parse_extract_field(
actstr, None, r"(\d+)", lambda x: int(x), False, "0"
)
self["attrs"].append(["OVS_ACTION_ATTR_OUTPUT", output])
parsed = True
elif parse_starts_block(actstr, "recirc(", False):
actstr, recircid = parse_extract_field(
actstr,
"recirc(",
r"([0-9a-fA-Fx]+)",
lambda x: int(x, 0),
False,
0,
)
parencount += 1
self["attrs"].append(["OVS_ACTION_ATTR_RECIRC", recircid])
parsed = True
parse_flat_map = (
("ct_clear", "OVS_ACTION_ATTR_CT_CLEAR"),
("pop_vlan", "OVS_ACTION_ATTR_POP_VLAN"),
("pop_eth", "OVS_ACTION_ATTR_POP_ETH"),
("pop_nsh", "OVS_ACTION_ATTR_POP_NSH"),
)
for flat_act in parse_flat_map:
if parse_starts_block(actstr, flat_act[0], False):
actstr = actstr[len(flat_act[0]):]
self["attrs"].append([flat_act[1], True])
actstr = actstr[strspn(actstr, ", ") :]
parsed = True
if parse_starts_block(actstr, "clone(", False):
parencount += 1
subacts = ovsactions()
actstr = actstr[len("clone("):]
parsedLen = subacts.parse(actstr)
lst = []
self["attrs"].append(("OVS_ACTION_ATTR_CLONE", subacts))
actstr = actstr[parsedLen:]
parsed = True
elif parse_starts_block(actstr, "set(", False):
parencount += 1
k = ovskey()
actstr = actstr[len("set("):]
actstr = k.parse(actstr, None)
self["attrs"].append(("OVS_ACTION_ATTR_SET", k))
if not actstr.startswith(")"):
actstr = ")" + actstr
parsed = True
elif parse_starts_block(actstr, "set_masked(", False):
parencount += 1
k = ovskey()
m = ovskey()
actstr = actstr[len("set_masked("):]
actstr = k.parse(actstr, m)
self["attrs"].append(("OVS_ACTION_ATTR_SET_MASKED", [k, m]))
if not actstr.startswith(")"):
actstr = ")" + actstr
parsed = True
elif parse_starts_block(actstr, "ct(", False):
parencount += 1
actstr = actstr[len("ct(") :]
ctact = ovsactions.ctact()
for scan in (
("commit", "OVS_CT_ATTR_COMMIT", None),
("force_commit", "OVS_CT_ATTR_FORCE_COMMIT", None),
("zone", "OVS_CT_ATTR_ZONE", int),
("mark", "OVS_CT_ATTR_MARK", int),
("helper", "OVS_CT_ATTR_HELPER", lambda x, y: str(x)),
("timeout", "OVS_CT_ATTR_TIMEOUT", lambda x, y: str(x)),
):
if actstr.startswith(scan[0]):
actstr = actstr[len(scan[0]) :]
if scan[2] is not None:
if actstr[0] != "=":
raise ValueError("Invalid ct attr")
actstr = actstr[1:]
pos = strcspn(actstr, ",)")
datum = scan[2](actstr[:pos], 0)
ctact["attrs"].append([scan[1], datum])
actstr = actstr[pos:]
else:
ctact["attrs"].append([scan[1], None])
actstr = actstr[strspn(actstr, ", ") :]
# it seems strange to put this here, but nat() is a complex
# sub-action and this lets it sit anywhere in the ct() action
if actstr.startswith("nat"):
actstr = actstr[3:]
natact = ovsactions.ctact.natattr()
if actstr.startswith("("):
parencount += 1
t = None
actstr = actstr[1:]
if actstr.startswith("src"):
t = "OVS_NAT_ATTR_SRC"
actstr = actstr[3:]
elif actstr.startswith("dst"):
t = "OVS_NAT_ATTR_DST"
actstr = actstr[3:]
actstr, ip_block_min = parse_extract_field(
actstr, "=", r"([0-9a-fA-F\.]+)", str, False
)
actstr, ip_block_max = parse_extract_field(
actstr, "-", r"([0-9a-fA-F\.]+)", str, False
)
actstr, proto_min = parse_extract_field(
actstr, ":", r"(\d+)", int, False
)
actstr, proto_max = parse_extract_field(
actstr, "-", r"(\d+)", int, False
)
if t is not None:
natact["attrs"].append([t, None])
if ip_block_min is not None:
natact["attrs"].append(
["OVS_NAT_ATTR_IP_MIN", ip_block_min]
)
if ip_block_max is not None:
natact["attrs"].append(
["OVS_NAT_ATTR_IP_MAX", ip_block_max]
)
if proto_min is not None:
natact["attrs"].append(
["OVS_NAT_ATTR_PROTO_MIN", proto_min]
)
if proto_max is not None:
natact["attrs"].append(
["OVS_NAT_ATTR_PROTO_MAX", proto_max]
)
for natscan in (
("persistent", "OVS_NAT_ATTR_PERSISTENT"),
("hash", "OVS_NAT_ATTR_PROTO_HASH"),
("random", "OVS_NAT_ATTR_PROTO_RANDOM"),
):
if actstr.startswith(natscan[0]):
actstr = actstr[len(natscan[0]) :]
natact["attrs"].append([natscan[1], None])
actstr = actstr[strspn(actstr, ", ") :]
ctact["attrs"].append(["OVS_CT_ATTR_NAT", natact])
actstr = actstr[strspn(actstr, ", ") :]
self["attrs"].append(["OVS_ACTION_ATTR_CT", ctact])
parsed = True
elif parse_starts_block(actstr, "sample(", False):
sampleact = self.sample()
actstr = sampleact.parse(actstr[len("sample(") : ])
self["attrs"].append(["OVS_ACTION_ATTR_SAMPLE", sampleact])
parsed = True
elif parse_starts_block(actstr, "psample(", False):
psampleact = self.psample()
actstr = psampleact.parse(actstr[len("psample(") : ])
self["attrs"].append(["OVS_ACTION_ATTR_PSAMPLE", psampleact])
parsed = True
elif parse_starts_block(actstr, "userspace(", False):
uact = self.userspace()
actstr = uact.parse(actstr[len("userspace(") : ])
self["attrs"].append(["OVS_ACTION_ATTR_USERSPACE", uact])
parsed = True
elif parse_starts_block(actstr, "trunc(", False):
parencount += 1
actstr, val = parse_extract_field(
actstr,
"trunc(",
r"([0-9]+)",
int,
False,
None,
)
self["attrs"].append(["OVS_ACTION_ATTR_TRUNC", val])
parsed = True
actstr = actstr[strspn(actstr, ", ") :]
while parencount > 0:
parencount -= 1
actstr = actstr[strspn(actstr, " "):]
if len(actstr) and actstr[0] != ")":
raise ValueError("Action str: '%s' unbalanced" % actstr)
actstr = actstr[1:]
if len(actstr) and actstr[0] == ")":
return (totallen - len(actstr))
actstr = actstr[strspn(actstr, ", ") :]
if not parsed:
raise ValueError("Action str: '%s' not supported" % actstr)
return (totallen - len(actstr))
class ovskey(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_KEY_ATTR_UNSPEC", "none"),
("OVS_KEY_ATTR_ENCAP", "none"),
("OVS_KEY_ATTR_PRIORITY", "uint32"),
("OVS_KEY_ATTR_IN_PORT", "uint32"),
("OVS_KEY_ATTR_ETHERNET", "ethaddr"),
("OVS_KEY_ATTR_VLAN", "uint16"),
("OVS_KEY_ATTR_ETHERTYPE", "be16"),
("OVS_KEY_ATTR_IPV4", "ovs_key_ipv4"),
("OVS_KEY_ATTR_IPV6", "ovs_key_ipv6"),
("OVS_KEY_ATTR_TCP", "ovs_key_tcp"),
("OVS_KEY_ATTR_UDP", "ovs_key_udp"),
("OVS_KEY_ATTR_ICMP", "ovs_key_icmp"),
("OVS_KEY_ATTR_ICMPV6", "ovs_key_icmpv6"),
("OVS_KEY_ATTR_ARP", "ovs_key_arp"),
("OVS_KEY_ATTR_ND", "ovs_key_nd"),
("OVS_KEY_ATTR_SKB_MARK", "uint32"),
("OVS_KEY_ATTR_TUNNEL", "ovs_key_tunnel"),
("OVS_KEY_ATTR_SCTP", "ovs_key_sctp"),
("OVS_KEY_ATTR_TCP_FLAGS", "be16"),
("OVS_KEY_ATTR_DP_HASH", "uint32"),
("OVS_KEY_ATTR_RECIRC_ID", "uint32"),
("OVS_KEY_ATTR_MPLS", "array(ovs_key_mpls)"),
("OVS_KEY_ATTR_CT_STATE", "uint32"),
("OVS_KEY_ATTR_CT_ZONE", "uint16"),
("OVS_KEY_ATTR_CT_MARK", "uint32"),
("OVS_KEY_ATTR_CT_LABELS", "none"),
("OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4", "ovs_key_ct_tuple_ipv4"),
("OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6", "ovs_key_ct_tuple_ipv6"),
("OVS_KEY_ATTR_NSH", "none"),
("OVS_KEY_ATTR_PACKET_TYPE", "none"),
("OVS_KEY_ATTR_ND_EXTENSIONS", "none"),
("OVS_KEY_ATTR_TUNNEL_INFO", "none"),
("OVS_KEY_ATTR_IPV6_EXTENSIONS", "none"),
)
class ovs_key_proto(nla):
fields = (
("src", "!H"),
("dst", "!H"),
)
fields_map = (
("src", "src", "%d", lambda x: int(x) if x else 0,
convert_int(16)),
("dst", "dst", "%d", lambda x: int(x) if x else 0,
convert_int(16)),
)
def __init__(
self,
protostr,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
self.proto_str = protostr
nla.__init__(
self,
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
def parse(self, flowstr, typeInst):
if not flowstr.startswith(self.proto_str):
return None, None
k = typeInst()
m = typeInst()
flowstr = flowstr[len(self.proto_str) :]
if flowstr.startswith("("):
flowstr = flowstr[1:]
keybits = b""
maskbits = b""
for f in self.fields_map:
if flowstr.startswith(f[1]):
# the following assumes that the field looks
# something like 'field.' where '.' is a
# character that we don't exactly care about.
flowstr = flowstr[len(f[1]) + 1 :]
splitchar = 0
for c in flowstr:
if c == "," or c == ")":
break
splitchar += 1
data = flowstr[:splitchar]
flowstr = flowstr[splitchar:]
else:
data = ""
if len(f) > 4:
k[f[0]], m[f[0]] = f[4](data)
else:
k[f[0]] = f[3](data)
m[f[0]] = f[3](data)
flowstr = flowstr[strspn(flowstr, ", ") :]
if len(flowstr) == 0:
return flowstr, k, m
flowstr = flowstr[strspn(flowstr, "), ") :]
return flowstr, k, m
def dpstr(self, masked=None, more=False):
outstr = self.proto_str + "("
first = False
for f in self.fields_map:
if first:
outstr += ","
if masked is None:
outstr += "%s=" % f[0]
if isinstance(f[2], str):
outstr += f[2] % self[f[1]]
else:
outstr += f[2](self[f[1]])
first = True
elif more or f[3](masked[f[1]]) != 0:
outstr += "%s=" % f[0]
if isinstance(f[2], str):
outstr += f[2] % self[f[1]]
else:
outstr += f[2](self[f[1]])
outstr += "/"
if isinstance(f[2], str):
outstr += f[2] % masked[f[1]]
else:
outstr += f[2](masked[f[1]])
first = True
outstr += ")"
return outstr
class ethaddr(ovs_key_proto):
fields = (
("src", "!6s"),
("dst", "!6s"),
)
fields_map = (
(
"src",
"src",
macstr,
lambda x: int.from_bytes(x, "big"),
convert_mac,
),
(
"dst",
"dst",
macstr,
lambda x: int.from_bytes(x, "big"),
convert_mac,
),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"eth",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_ipv4(ovs_key_proto):
fields = (
("src", "!I"),
("dst", "!I"),
("proto", "B"),
("tos", "B"),
("ttl", "B"),
("frag", "B"),
)
fields_map = (
(
"src",
"src",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
(
"dst",
"dst",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
("proto", "proto", "%d", lambda x: int(x) if x else 0,
convert_int(8)),
("tos", "tos", "%d", lambda x: int(x) if x else 0,
convert_int(8)),
("ttl", "ttl", "%d", lambda x: int(x) if x else 0,
convert_int(8)),
("frag", "frag", "%d", lambda x: int(x) if x else 0,
convert_int(8)),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"ipv4",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_ipv6(ovs_key_proto):
fields = (
("src", "!16s"),
("dst", "!16s"),
("label", "!I"),
("proto", "B"),
("tclass", "B"),
("hlimit", "B"),
("frag", "B"),
)
fields_map = (
(
"src",
"src",
lambda x: str(ipaddress.IPv6Address(x)),
lambda x: ipaddress.IPv6Address(x).packed if x else 0,
convert_ipv6,
),
(
"dst",
"dst",
lambda x: str(ipaddress.IPv6Address(x)),
lambda x: ipaddress.IPv6Address(x).packed if x else 0,
convert_ipv6,
),
("label", "label", "%d", lambda x: int(x) if x else 0),
("proto", "proto", "%d", lambda x: int(x) if x else 0),
("tclass", "tclass", "%d", lambda x: int(x) if x else 0),
("hlimit", "hlimit", "%d", lambda x: int(x) if x else 0),
("frag", "frag", "%d", lambda x: int(x) if x else 0),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"ipv6",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_tcp(ovs_key_proto):
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"tcp",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_udp(ovs_key_proto):
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"udp",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_sctp(ovs_key_proto):
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"sctp",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_icmp(ovs_key_proto):
fields = (
("type", "B"),
("code", "B"),
)
fields_map = (
("type", "type", "%d", lambda x: int(x) if x else 0),
("code", "code", "%d", lambda x: int(x) if x else 0),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"icmp",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_icmpv6(ovs_key_icmp):
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"icmpv6",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_arp(ovs_key_proto):
fields = (
("sip", "!I"),
("tip", "!I"),
("op", "!H"),
("sha", "!6s"),
("tha", "!6s"),
("pad", "xx"),
)
fields_map = (
(
"sip",
"sip",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
(
"tip",
"tip",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
("op", "op", "%d", lambda x: int(x) if x else 0),
(
"sha",
"sha",
macstr,
lambda x: int.from_bytes(x, "big"),
convert_mac,
),
(
"tha",
"tha",
macstr,
lambda x: int.from_bytes(x, "big"),
convert_mac,
),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"arp",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_nd(ovs_key_proto):
fields = (
("target", "!16s"),
("sll", "!6s"),
("tll", "!6s"),
)
fields_map = (
(
"target",
"target",
lambda x: str(ipaddress.IPv6Address(x)),
convert_ipv6,
),
("sll", "sll", macstr, lambda x: int.from_bytes(x, "big")),
("tll", "tll", macstr, lambda x: int.from_bytes(x, "big")),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"nd",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_ct_tuple_ipv4(ovs_key_proto):
fields = (
("src", "!I"),
("dst", "!I"),
("tp_src", "!H"),
("tp_dst", "!H"),
("proto", "B"),
)
fields_map = (
(
"src",
"src",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
(
"dst",
"dst",
lambda x: str(ipaddress.IPv4Address(x)),
int,
convert_ipv4,
),
("tp_src", "tp_src", "%d", int),
("tp_dst", "tp_dst", "%d", int),
("proto", "proto", "%d", int),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"ct_tuple4",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_ct_tuple_ipv6(nla):
fields = (
("src", "!16s"),
("dst", "!16s"),
("tp_src", "!H"),
("tp_dst", "!H"),
("proto", "B"),
)
fields_map = (
(
"src",
"src",
lambda x: str(ipaddress.IPv6Address(x)),
convert_ipv6,
),
(
"dst",
"dst",
lambda x: str(ipaddress.IPv6Address(x)),
convert_ipv6,
),
("tp_src", "tp_src", "%d", int),
("tp_dst", "tp_dst", "%d", int),
("proto", "proto", "%d", int),
)
def __init__(
self,
data=None,
offset=None,
parent=None,
length=None,
init=None,
):
ovskey.ovs_key_proto.__init__(
self,
"ct_tuple6",
data=data,
offset=offset,
parent=parent,
length=length,
init=init,
)
class ovs_key_tunnel(nla):
nla_flags = NLA_F_NESTED
nla_map = (
("OVS_TUNNEL_KEY_ATTR_ID", "be64"),
("OVS_TUNNEL_KEY_ATTR_IPV4_SRC", "ipaddr"),
("OVS_TUNNEL_KEY_ATTR_IPV4_DST", "ipaddr"),
("OVS_TUNNEL_KEY_ATTR_TOS", "uint8"),
("OVS_TUNNEL_KEY_ATTR_TTL", "uint8"),
("OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT", "flag"),
("OVS_TUNNEL_KEY_ATTR_CSUM", "flag"),
("OVS_TUNNEL_KEY_ATTR_OAM", "flag"),
("OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS", "array(uint32)"),
("OVS_TUNNEL_KEY_ATTR_TP_SRC", "be16"),
("OVS_TUNNEL_KEY_ATTR_TP_DST", "be16"),
("OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS", "none"),
("OVS_TUNNEL_KEY_ATTR_IPV6_SRC", "ipaddr"),
("OVS_TUNNEL_KEY_ATTR_IPV6_DST", "ipaddr"),
("OVS_TUNNEL_KEY_ATTR_PAD", "none"),
("OVS_TUNNEL_KEY_ATTR_ERSPAN_OPTS", "none"),
("OVS_TUNNEL_KEY_ATTR_IPV4_INFO_BRIDGE", "flag"),
)
def parse(self, flowstr, mask=None):
if not flowstr.startswith("tunnel("):
return None, None
k = ovskey.ovs_key_tunnel()
if mask is not None:
mask = ovskey.ovs_key_tunnel()
flowstr = flowstr[len("tunnel("):]
v6_address = None
fields = [
("tun_id=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_ID",
0xffffffffffffffff, None, None),
("src=", r"([0-9a-fA-F\.]+)", str,
"OVS_TUNNEL_KEY_ATTR_IPV4_SRC", "255.255.255.255", "0.0.0.0",
False),
("dst=", r"([0-9a-fA-F\.]+)", str,
"OVS_TUNNEL_KEY_ATTR_IPV4_DST", "255.255.255.255", "0.0.0.0",
False),
("ipv6_src=", r"([0-9a-fA-F:]+)", str,
"OVS_TUNNEL_KEY_ATTR_IPV6_SRC",
"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", True),
("ipv6_dst=", r"([0-9a-fA-F:]+)", str,
"OVS_TUNNEL_KEY_ATTR_IPV6_DST",
"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", True),
("tos=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TOS", 255, 0,
None),
("ttl=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TTL", 255, 0,
None),
("tp_src=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TP_SRC",
65535, 0, None),
("tp_dst=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TP_DST",
65535, 0, None),
]
forced_include = ["OVS_TUNNEL_KEY_ATTR_TTL"]
for prefix, regex, typ, attr_name, mask_val, default_val, v46_flag in fields:
flowstr, value = parse_extract_field(flowstr, prefix, regex, typ, False)
if not attr_name:
raise Exception("Bad list value in tunnel fields")
if value is None and attr_name in forced_include:
value = default_val
mask_val = default_val
if value is not None:
if v46_flag is not None:
if v6_address is None:
v6_address = v46_flag
if v46_flag != v6_address:
raise ValueError("Cannot mix v6 and v4 addresses")
k["attrs"].append([attr_name, value])
if mask is not None:
mask["attrs"].append([attr_name, mask_val])
else:
if v46_flag is not None:
if v6_address is None or v46_flag != v6_address:
continue
if mask is not None:
mask["attrs"].append([attr_name, default_val])
if k["attrs"][0][0] != "OVS_TUNNEL_KEY_ATTR_ID":
raise ValueError("Needs a tunid set")
if flowstr.startswith("flags("):
flowstr = flowstr[len("flags("):]
flagspos = flowstr.find(")")
flags = flowstr[:flagspos]
flowstr = flowstr[flagspos + 1:]
flag_attrs = {
"df": "OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT",
"csum": "OVS_TUNNEL_KEY_ATTR_CSUM",
"oam": "OVS_TUNNEL_KEY_ATTR_OAM"
}
for flag in flags.split("|"):
if flag in flag_attrs:
k["attrs"].append([flag_attrs[flag], True])
if mask is not None:
mask["attrs"].append([flag_attrs[flag], True])
flowstr = flowstr[strspn(flowstr, ", ") :]
return flowstr, k, mask
def dpstr(self, mask=None, more=False):
print_str = "tunnel("
flagsattrs = []
for k in self["attrs"]:
noprint = False
if k[0] == "OVS_TUNNEL_KEY_ATTR_ID":
print_str += "tun_id=%d" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV4_SRC":
print_str += "src=%s" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV4_DST":
print_str += "dst=%s" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV6_SRC":
print_str += "ipv6_src=%s" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV6_DST":
print_str += "ipv6_dst=%s" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_TOS":
print_str += "tos=%d" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_TTL":
print_str += "ttl=%d" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_TP_SRC":
print_str += "tp_src=%d" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_TP_DST":
print_str += "tp_dst=%d" % k[1]
elif k[0] == "OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT":
noprint = True
flagsattrs.append("df")
elif k[0] == "OVS_TUNNEL_KEY_ATTR_CSUM":
noprint = True
flagsattrs.append("csum")
elif k[0] == "OVS_TUNNEL_KEY_ATTR_OAM":
noprint = True
flagsattrs.append("oam")
if not noprint:
print_str += ","
if len(flagsattrs):
print_str += "flags(" + "|".join(flagsattrs) + ")"
print_str += ")"
return print_str
class ovs_key_mpls(nla):
fields = (("lse", ">I"),)
def parse(self, flowstr, mask=None):
for field in (
("OVS_KEY_ATTR_PRIORITY", "skb_priority", intparse),
("OVS_KEY_ATTR_SKB_MARK", "skb_mark", intparse),
("OVS_KEY_ATTR_RECIRC_ID", "recirc_id", intparse),
("OVS_KEY_ATTR_TUNNEL", "tunnel", ovskey.ovs_key_tunnel),
("OVS_KEY_ATTR_DP_HASH", "dp_hash", intparse),
("OVS_KEY_ATTR_CT_STATE", "ct_state", parse_ct_state),
("OVS_KEY_ATTR_CT_ZONE", "ct_zone", intparse),
("OVS_KEY_ATTR_CT_MARK", "ct_mark", intparse),
("OVS_KEY_ATTR_IN_PORT", "in_port", intparse),
(
"OVS_KEY_ATTR_ETHERNET",
"eth",
ovskey.ethaddr,
),
(
"OVS_KEY_ATTR_ETHERTYPE",
"eth_type",
lambda x: intparse(x, "0xffff"),
),
(
"OVS_KEY_ATTR_IPV4",
"ipv4",
ovskey.ovs_key_ipv4,
),
(
"OVS_KEY_ATTR_IPV6",
"ipv6",
ovskey.ovs_key_ipv6,
),
(
"OVS_KEY_ATTR_ARP",
"arp",
ovskey.ovs_key_arp,
),
(
"OVS_KEY_ATTR_TCP",
"tcp",
ovskey.ovs_key_tcp,
),
(
"OVS_KEY_ATTR_UDP",
"udp",
ovskey.ovs_key_udp,
),
(
"OVS_KEY_ATTR_ICMP",
"icmp",
ovskey.ovs_key_icmp,
),
(
"OVS_KEY_ATTR_TCP_FLAGS",
"tcp_flags",
lambda x: parse_flags(x, None),
),
):
fld = field[1] + "("
if not flowstr.startswith(fld):
continue
if not isinstance(field[2], types.FunctionType):
nk = field[2]()
flowstr, k, m = nk.parse(flowstr, field[2])
else:
flowstr = flowstr[len(fld) :]
flowstr, k, m = field[2](flowstr)
if m and mask is not None:
mask["attrs"].append([field[0], m])
self["attrs"].append([field[0], k])
flowstr = flowstr[strspn(flowstr, "), ") :]
return flowstr
def dpstr(self, mask=None, more=False):
print_str = ""
for field in (
(
"OVS_KEY_ATTR_PRIORITY",
"skb_priority",
"%d",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_SKB_MARK",
"skb_mark",
"%d",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_RECIRC_ID",
"recirc_id",
"0x%08X",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_DP_HASH",
"dp_hash",
"0x%08X",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_TUNNEL",
"tunnel",
None,
False,
False,
),
(
"OVS_KEY_ATTR_CT_STATE",
"ct_state",
"0x%04x",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_CT_ZONE",
"ct_zone",
"0x%04x",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_CT_MARK",
"ct_mark",
"0x%08x",
lambda x: False,
True,
),
(
"OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4",
None,
None,
False,
False,
),
(
"OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6",
None,
None,
False,
False,
),
(
"OVS_KEY_ATTR_IN_PORT",
"in_port",
"%d",
lambda x: True,
True,
),
("OVS_KEY_ATTR_ETHERNET", None, None, False, False),
(
"OVS_KEY_ATTR_ETHERTYPE",
"eth_type",
"0x%04x",
lambda x: int(x) == 0xFFFF,
True,
),
("OVS_KEY_ATTR_IPV4", None, None, False, False),
("OVS_KEY_ATTR_IPV6", None, None, False, False),
("OVS_KEY_ATTR_ARP", None, None, False, False),
("OVS_KEY_ATTR_TCP", None, None, False, False),
(
"OVS_KEY_ATTR_TCP_FLAGS",
"tcp_flags",
"0x%04x",
lambda x: False,
True,
),
("OVS_KEY_ATTR_UDP", None, None, False, False),
("OVS_KEY_ATTR_SCTP", None, None, False, False),
("OVS_KEY_ATTR_ICMP", None, None, False, False),
("OVS_KEY_ATTR_ICMPV6", None, None, False, False),
("OVS_KEY_ATTR_ND", None, None, False, False),
):
v = self.get_attr(field[0])
if v is not None:
m = None if mask is None else mask.get_attr(field[0])
if field[4] is False:
print_str += v.dpstr(m, more)
print_str += ","
else:
if m is None or field[3](m):
print_str += field[1] + "("
print_str += field[2] % v
print_str += "),"
elif more or m != 0:
print_str += field[1] + "("
print_str += (field[2] % v) + "/" + (field[2] % m)
print_str += "),"
return print_str
class OvsPacket(GenericNetlinkSocket):
OVS_PACKET_CMD_MISS = 1 # Flow table miss
OVS_PACKET_CMD_ACTION = 2 # USERSPACE action
OVS_PACKET_CMD_EXECUTE = 3 # Apply actions to packet
class ovs_packet_msg(ovs_dp_msg):
nla_map = (
("OVS_PACKET_ATTR_UNSPEC", "none"),
("OVS_PACKET_ATTR_PACKET", "array(uint8)"),
("OVS_PACKET_ATTR_KEY", "ovskey"),
("OVS_PACKET_ATTR_ACTIONS", "ovsactions"),
("OVS_PACKET_ATTR_USERDATA", "none"),
("OVS_PACKET_ATTR_EGRESS_TUN_KEY", "none"),
("OVS_PACKET_ATTR_UNUSED1", "none"),
("OVS_PACKET_ATTR_UNUSED2", "none"),
("OVS_PACKET_ATTR_PROBE", "none"),
("OVS_PACKET_ATTR_MRU", "uint16"),
("OVS_PACKET_ATTR_LEN", "uint32"),
("OVS_PACKET_ATTR_HASH", "uint64"),
)
def __init__(self):
GenericNetlinkSocket.__init__(self)
self.bind(OVS_PACKET_FAMILY, OvsPacket.ovs_packet_msg)
def upcall_handler(self, up=None):
print("listening on upcall packet handler:", self.epid)
while True:
try:
msgs = self.get()
for msg in msgs:
if not up:
continue
if msg["cmd"] == OvsPacket.OVS_PACKET_CMD_MISS:
up.miss(msg)
elif msg["cmd"] == OvsPacket.OVS_PACKET_CMD_ACTION:
up.action(msg)
elif msg["cmd"] == OvsPacket.OVS_PACKET_CMD_EXECUTE:
up.execute(msg)
else:
print("Unkonwn cmd: %d" % msg["cmd"])
except NetlinkError as ne:
raise ne
class OvsDatapath(GenericNetlinkSocket):
OVS_DP_F_VPORT_PIDS = 1 << 1
OVS_DP_F_DISPATCH_UPCALL_PER_CPU = 1 << 3
class dp_cmd_msg(ovs_dp_msg):
"""
Message class that will be used to communicate with the kernel module.
"""
nla_map = (
("OVS_DP_ATTR_UNSPEC", "none"),
("OVS_DP_ATTR_NAME", "asciiz"),
("OVS_DP_ATTR_UPCALL_PID", "array(uint32)"),
("OVS_DP_ATTR_STATS", "dpstats"),
("OVS_DP_ATTR_MEGAFLOW_STATS", "megaflowstats"),
("OVS_DP_ATTR_USER_FEATURES", "uint32"),
("OVS_DP_ATTR_PAD", "none"),
("OVS_DP_ATTR_MASKS_CACHE_SIZE", "uint32"),
("OVS_DP_ATTR_PER_CPU_PIDS", "array(uint32)"),
)
class dpstats(nla):
fields = (
("hit", "=Q"),
("missed", "=Q"),
("lost", "=Q"),
("flows", "=Q"),
)
class megaflowstats(nla):
fields = (
("mask_hit", "=Q"),
("masks", "=I"),
("padding", "=I"),
("cache_hits", "=Q"),
("pad1", "=Q"),
)
def __init__(self):
GenericNetlinkSocket.__init__(self)
self.bind(OVS_DATAPATH_FAMILY, OvsDatapath.dp_cmd_msg)
def info(self, dpname, ifindex=0):
msg = OvsDatapath.dp_cmd_msg()
msg["cmd"] = OVS_DP_CMD_GET
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = ifindex
msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.ENODEV:
reply = None
else:
raise ne
return reply
def create(
self, dpname, shouldUpcall=False, versionStr=None, p=OvsPacket()
):
msg = OvsDatapath.dp_cmd_msg()
msg["cmd"] = OVS_DP_CMD_NEW
if versionStr is None:
msg["version"] = OVS_DATAPATH_VERSION
else:
msg["version"] = int(versionStr.split(":")[0], 0)
msg["reserved"] = 0
msg["dpifindex"] = 0
msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
dpfeatures = 0
if versionStr is not None and versionStr.find(":") != -1:
dpfeatures = int(versionStr.split(":")[1], 0)
else:
if versionStr is None or versionStr.find(":") == -1:
dpfeatures |= OvsDatapath.OVS_DP_F_DISPATCH_UPCALL_PER_CPU
dpfeatures &= ~OvsDatapath.OVS_DP_F_VPORT_PIDS
nproc = multiprocessing.cpu_count()
procarray = []
for i in range(1, nproc):
procarray += [int(p.epid)]
msg["attrs"].append(["OVS_DP_ATTR_UPCALL_PID", procarray])
msg["attrs"].append(["OVS_DP_ATTR_USER_FEATURES", dpfeatures])
if not shouldUpcall:
msg["attrs"].append(["OVS_DP_ATTR_UPCALL_PID", [0]])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.EEXIST:
reply = None
else:
raise ne
return reply
def destroy(self, dpname):
msg = OvsDatapath.dp_cmd_msg()
msg["cmd"] = OVS_DP_CMD_DEL
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = 0
msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.ENODEV:
reply = None
else:
raise ne
return reply
class OvsVport(GenericNetlinkSocket):
OVS_VPORT_TYPE_NETDEV = 1
OVS_VPORT_TYPE_INTERNAL = 2
OVS_VPORT_TYPE_GRE = 3
OVS_VPORT_TYPE_VXLAN = 4
OVS_VPORT_TYPE_GENEVE = 5
class ovs_vport_msg(ovs_dp_msg):
nla_map = (
("OVS_VPORT_ATTR_UNSPEC", "none"),
("OVS_VPORT_ATTR_PORT_NO", "uint32"),
("OVS_VPORT_ATTR_TYPE", "uint32"),
("OVS_VPORT_ATTR_NAME", "asciiz"),
("OVS_VPORT_ATTR_OPTIONS", "vportopts"),
("OVS_VPORT_ATTR_UPCALL_PID", "array(uint32)"),
("OVS_VPORT_ATTR_STATS", "vportstats"),
("OVS_VPORT_ATTR_PAD", "none"),
("OVS_VPORT_ATTR_IFINDEX", "uint32"),
("OVS_VPORT_ATTR_NETNSID", "uint32"),
)
class vportopts(nla):
nla_map = (
("OVS_TUNNEL_ATTR_UNSPEC", "none"),
("OVS_TUNNEL_ATTR_DST_PORT", "uint16"),
("OVS_TUNNEL_ATTR_EXTENSION", "none"),
)
class vportstats(nla):
fields = (
("rx_packets", "=Q"),
("tx_packets", "=Q"),
("rx_bytes", "=Q"),
("tx_bytes", "=Q"),
("rx_errors", "=Q"),
("tx_errors", "=Q"),
("rx_dropped", "=Q"),
("tx_dropped", "=Q"),
)
def type_to_str(vport_type):
if vport_type == OvsVport.OVS_VPORT_TYPE_NETDEV:
return "netdev"
elif vport_type == OvsVport.OVS_VPORT_TYPE_INTERNAL:
return "internal"
elif vport_type == OvsVport.OVS_VPORT_TYPE_GRE:
return "gre"
elif vport_type == OvsVport.OVS_VPORT_TYPE_VXLAN:
return "vxlan"
elif vport_type == OvsVport.OVS_VPORT_TYPE_GENEVE:
return "geneve"
raise ValueError("Unknown vport type:%d" % vport_type)
def str_to_type(vport_type):
if vport_type == "netdev":
return OvsVport.OVS_VPORT_TYPE_NETDEV
elif vport_type == "internal":
return OvsVport.OVS_VPORT_TYPE_INTERNAL
elif vport_type == "gre":
return OvsVport.OVS_VPORT_TYPE_INTERNAL
elif vport_type == "vxlan":
return OvsVport.OVS_VPORT_TYPE_VXLAN
elif vport_type == "geneve":
return OvsVport.OVS_VPORT_TYPE_GENEVE
raise ValueError("Unknown vport type: '%s'" % vport_type)
def __init__(self, packet=OvsPacket()):
GenericNetlinkSocket.__init__(self)
self.bind(OVS_VPORT_FAMILY, OvsVport.ovs_vport_msg)
self.upcall_packet = packet
def info(self, vport_name, dpifindex=0, portno=None):
msg = OvsVport.ovs_vport_msg()
msg["cmd"] = OVS_VPORT_CMD_GET
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = dpifindex
if portno is None:
msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_name])
else:
msg["attrs"].append(["OVS_VPORT_ATTR_PORT_NO", portno])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.ENODEV:
reply = None
else:
raise ne
return reply
def attach(self, dpindex, vport_ifname, ptype, dport, lwt):
msg = OvsVport.ovs_vport_msg()
msg["cmd"] = OVS_VPORT_CMD_NEW
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = dpindex
port_type = OvsVport.str_to_type(ptype)
msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
msg["attrs"].append(
["OVS_VPORT_ATTR_UPCALL_PID", [self.upcall_packet.epid]]
)
TUNNEL_DEFAULTS = [("geneve", 6081),
("vxlan", 4789)]
for tnl in TUNNEL_DEFAULTS:
if ptype == tnl[0]:
if not dport:
dport = tnl[1]
if not lwt:
vportopt = OvsVport.ovs_vport_msg.vportopts()
vportopt["attrs"].append(
["OVS_TUNNEL_ATTR_DST_PORT", socket.htons(dport)]
)
msg["attrs"].append(
["OVS_VPORT_ATTR_OPTIONS", vportopt]
)
else:
port_type = OvsVport.OVS_VPORT_TYPE_NETDEV
ipr = pyroute2.iproute.IPRoute()
if tnl[0] == "geneve":
ipr.link("add", ifname=vport_ifname, kind=tnl[0],
geneve_port=dport,
geneve_collect_metadata=True,
geneve_udp_zero_csum6_rx=1)
elif tnl[0] == "vxlan":
ipr.link("add", ifname=vport_ifname, kind=tnl[0],
vxlan_learning=0, vxlan_collect_metadata=1,
vxlan_udp_zero_csum6_rx=1, vxlan_port=dport)
break
msg["attrs"].append(["OVS_VPORT_ATTR_TYPE", port_type])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.EEXIST:
reply = None
else:
raise ne
return reply
def reset_upcall(self, dpindex, vport_ifname, p=None):
msg = OvsVport.ovs_vport_msg()
msg["cmd"] = OVS_VPORT_CMD_SET
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = dpindex
msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
if p == None:
p = self.upcall_packet
else:
self.upcall_packet = p
msg["attrs"].append(["OVS_VPORT_ATTR_UPCALL_PID", [p.epid]])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
)
reply = reply[0]
except NetlinkError as ne:
raise ne
return reply
def detach(self, dpindex, vport_ifname):
msg = OvsVport.ovs_vport_msg()
msg["cmd"] = OVS_VPORT_CMD_DEL
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = dpindex
msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
try:
reply = self.nlm_request(
msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
)
reply = reply[0]
except NetlinkError as ne:
if ne.code == errno.ENODEV:
reply = None
else:
raise ne
return reply
def upcall_handler(self, handler=None):
self.upcall_packet.upcall_handler(handler)
class OvsFlow(GenericNetlinkSocket):
class ovs_flow_msg(ovs_dp_msg):
nla_map = (
("OVS_FLOW_ATTR_UNSPEC", "none"),
("OVS_FLOW_ATTR_KEY", "ovskey"),
("OVS_FLOW_ATTR_ACTIONS", "ovsactions"),
("OVS_FLOW_ATTR_STATS", "flowstats"),
("OVS_FLOW_ATTR_TCP_FLAGS", "uint8"),
("OVS_FLOW_ATTR_USED", "uint64"),
("OVS_FLOW_ATTR_CLEAR", "none"),
("OVS_FLOW_ATTR_MASK", "ovskey"),
("OVS_FLOW_ATTR_PROBE", "none"),
("OVS_FLOW_ATTR_UFID", "array(uint32)"),
("OVS_FLOW_ATTR_UFID_FLAGS", "uint32"),
)
class flowstats(nla):
fields = (
("packets", "=Q"),
("bytes", "=Q"),
)
def dpstr(self, more=False):
ufid = self.get_attr("OVS_FLOW_ATTR_UFID")
ufid_str = ""
if ufid is not None:
ufid_str = (
"ufid:{:08x}-{:04x}-{:04x}-{:04x}-{:04x}{:08x}".format(
ufid[0],
ufid[1] >> 16,
ufid[1] & 0xFFFF,
ufid[2] >> 16,
ufid[2] & 0,
ufid[3],
)
)
key_field = self.get_attr("OVS_FLOW_ATTR_KEY")
keymsg = None
if key_field is not None:
keymsg = key_field
mask_field = self.get_attr("OVS_FLOW_ATTR_MASK")
maskmsg = None
if mask_field is not None:
maskmsg = mask_field
acts_field = self.get_attr("OVS_FLOW_ATTR_ACTIONS")
actsmsg = None
if acts_field is not None:
actsmsg = acts_field
print_str = ""
if more:
print_str += ufid_str + ","
if keymsg is not None:
print_str += keymsg.dpstr(maskmsg, more)
stats = self.get_attr("OVS_FLOW_ATTR_STATS")
if stats is None:
print_str += " packets:0, bytes:0,"
else:
print_str += " packets:%d, bytes:%d," % (
stats["packets"],
stats["bytes"],
)
used = self.get_attr("OVS_FLOW_ATTR_USED")
print_str += " used:"
if used is None:
print_str += "never,"
else:
used_time = int(used)
cur_time_sec = time.clock_gettime(time.CLOCK_MONOTONIC)
used_time = (cur_time_sec * 1000) - used_time
print_str += "{}s,".format(used_time / 1000)
print_str += " actions:"
if (
actsmsg is None
or "attrs" not in actsmsg
or len(actsmsg["attrs"]) == 0
):
print_str += "drop"
else:
print_str += actsmsg.dpstr(more)
return print_str
def parse(self, flowstr, actstr, dpidx=0):
OVS_UFID_F_OMIT_KEY = 1 << 0
OVS_UFID_F_OMIT_MASK = 1 << 1
OVS_UFID_F_OMIT_ACTIONS = 1 << 2
self["cmd"] = 0
self["version"] = 0
self["reserved"] = 0
self["dpifindex"] = 0
if flowstr.startswith("ufid:"):
count = 5
while flowstr[count] != ",":
count += 1
ufidstr = flowstr[5:count]
flowstr = flowstr[count + 1 :]
else:
ufidstr = str(uuid.uuid4())
uuidRawObj = uuid.UUID(ufidstr).fields
self["attrs"].append(
[
"OVS_FLOW_ATTR_UFID",
[
uuidRawObj[0],
uuidRawObj[1] << 16 | uuidRawObj[2],
uuidRawObj[3] << 24
| uuidRawObj[4] << 16
| uuidRawObj[5] & (0xFF << 32) >> 32,
uuidRawObj[5] & (0xFFFFFFFF),
],
]
)
self["attrs"].append(
[
"OVS_FLOW_ATTR_UFID_FLAGS",
int(
OVS_UFID_F_OMIT_KEY
| OVS_UFID_F_OMIT_MASK
| OVS_UFID_F_OMIT_ACTIONS
),
]
)
k = ovskey()
m = ovskey()
k.parse(flowstr, m)
self["attrs"].append(["OVS_FLOW_ATTR_KEY", k])
self["attrs"].append(["OVS_FLOW_ATTR_MASK", m])
a = ovsactions()
a.parse(actstr)
self["attrs"].append(["OVS_FLOW_ATTR_ACTIONS", a])
def __init__(self):
GenericNetlinkSocket.__init__(self)
self.bind(OVS_FLOW_FAMILY, OvsFlow.ovs_flow_msg)
def add_flow(self, dpifindex, flowmsg):
"""
Send a new flow message to the kernel.
dpifindex should be a valid datapath obtained by calling
into the OvsDatapath lookup
flowmsg is a flow object obtained by calling a dpparse
"""
flowmsg["cmd"] = OVS_FLOW_CMD_NEW
flowmsg["version"] = OVS_DATAPATH_VERSION
flowmsg["reserved"] = 0
flowmsg["dpifindex"] = dpifindex
try:
reply = self.nlm_request(
flowmsg,
msg_type=self.prid,
msg_flags=NLM_F_REQUEST | NLM_F_ACK,
)
reply = reply[0]
except NetlinkError as ne:
print(flowmsg)
raise ne
return reply
def del_flows(self, dpifindex):
"""
Send a del message to the kernel that will drop all flows.
dpifindex should be a valid datapath obtained by calling
into the OvsDatapath lookup
"""
flowmsg = OvsFlow.ovs_flow_msg()
flowmsg["cmd"] = OVS_FLOW_CMD_DEL
flowmsg["version"] = OVS_DATAPATH_VERSION
flowmsg["reserved"] = 0
flowmsg["dpifindex"] = dpifindex
try:
reply = self.nlm_request(
flowmsg,
msg_type=self.prid,
msg_flags=NLM_F_REQUEST | NLM_F_ACK,
)
reply = reply[0]
except NetlinkError as ne:
print(flowmsg)
raise ne
return reply
def dump(self, dpifindex, flowspec=None):
"""
Returns a list of messages containing flows.
dpifindex should be a valid datapath obtained by calling
into the OvsDatapath lookup
flowpsec is a string which represents a flow in the dpctl
format.
"""
msg = OvsFlow.ovs_flow_msg()
msg["cmd"] = OVS_FLOW_CMD_GET
msg["version"] = OVS_DATAPATH_VERSION
msg["reserved"] = 0
msg["dpifindex"] = dpifindex
msg_flags = NLM_F_REQUEST | NLM_F_ACK
if flowspec is None:
msg_flags |= NLM_F_DUMP
rep = None
try:
rep = self.nlm_request(
msg,
msg_type=self.prid,
msg_flags=msg_flags,
)
except NetlinkError as ne:
raise ne
return rep
def miss(self, packetmsg):
seq = packetmsg["header"]["sequence_number"]
keystr = "(none)"
key_field = packetmsg.get_attr("OVS_PACKET_ATTR_KEY")
if key_field is not None:
keystr = key_field.dpstr(None, True)
pktdata = packetmsg.get_attr("OVS_PACKET_ATTR_PACKET")
pktpres = "yes" if pktdata is not None else "no"
print("MISS upcall[%d/%s]: %s" % (seq, pktpres, keystr), flush=True)
def execute(self, packetmsg):
print("userspace execute command", flush=True)
def action(self, packetmsg):
print("userspace action command", flush=True)
class psample_sample(genlmsg):
nla_map = (
("PSAMPLE_ATTR_IIFINDEX", "none"),
("PSAMPLE_ATTR_OIFINDEX", "none"),
("PSAMPLE_ATTR_ORIGSIZE", "none"),
("PSAMPLE_ATTR_SAMPLE_GROUP", "uint32"),
("PSAMPLE_ATTR_GROUP_SEQ", "none"),
("PSAMPLE_ATTR_SAMPLE_RATE", "uint32"),
("PSAMPLE_ATTR_DATA", "array(uint8)"),
("PSAMPLE_ATTR_GROUP_REFCOUNT", "none"),
("PSAMPLE_ATTR_TUNNEL", "none"),
("PSAMPLE_ATTR_PAD", "none"),
("PSAMPLE_ATTR_OUT_TC", "none"),
("PSAMPLE_ATTR_OUT_TC_OCC", "none"),
("PSAMPLE_ATTR_LATENCY", "none"),
("PSAMPLE_ATTR_TIMESTAMP", "none"),
("PSAMPLE_ATTR_PROTO", "none"),
("PSAMPLE_ATTR_USER_COOKIE", "array(uint8)"),
)
def dpstr(self):
fields = []
data = ""
for (attr, value) in self["attrs"]:
if attr == "PSAMPLE_ATTR_SAMPLE_GROUP":
fields.append("group:%d" % value)
if attr == "PSAMPLE_ATTR_SAMPLE_RATE":
fields.append("rate:%d" % value)
if attr == "PSAMPLE_ATTR_USER_COOKIE":
value = "".join(format(x, "02x") for x in value)
fields.append("cookie:%s" % value)
if attr == "PSAMPLE_ATTR_DATA" and len(value) > 0:
data = "data:%s" % "".join(format(x, "02x") for x in value)
return ("%s %s" % (",".join(fields), data)).strip()
class psample_msg(Marshal):
PSAMPLE_CMD_SAMPLE = 0
PSAMPLE_CMD_GET_GROUP = 1
PSAMPLE_CMD_NEW_GROUP = 2
PSAMPLE_CMD_DEL_GROUP = 3
PSAMPLE_CMD_SET_FILTER = 4
msg_map = {PSAMPLE_CMD_SAMPLE: psample_sample}
class PsampleEvent(EventSocket):
genl_family = "psample"
mcast_groups = ["packets"]
marshal_class = psample_msg
def read_samples(self):
print("listening for psample events", flush=True)
while True:
try:
for msg in self.get():
print(msg.dpstr(), flush=True)
except NetlinkError as ne:
raise ne
def print_ovsdp_full(dp_lookup_rep, ifindex, ndb=NDB(), vpl=OvsVport()):
dp_name = dp_lookup_rep.get_attr("OVS_DP_ATTR_NAME")
base_stats = dp_lookup_rep.get_attr("OVS_DP_ATTR_STATS")
megaflow_stats = dp_lookup_rep.get_attr("OVS_DP_ATTR_MEGAFLOW_STATS")
user_features = dp_lookup_rep.get_attr("OVS_DP_ATTR_USER_FEATURES")
masks_cache_size = dp_lookup_rep.get_attr("OVS_DP_ATTR_MASKS_CACHE_SIZE")
print("%s:" % dp_name)
print(
" lookups: hit:%d missed:%d lost:%d"
% (base_stats["hit"], base_stats["missed"], base_stats["lost"])
)
print(" flows:%d" % base_stats["flows"])
pkts = base_stats["hit"] + base_stats["missed"]
avg = (megaflow_stats["mask_hit"] / pkts) if pkts != 0 else 0.0
print(
" masks: hit:%d total:%d hit/pkt:%f"
% (megaflow_stats["mask_hit"], megaflow_stats["masks"], avg)
)
print(" caches:")
print(" masks-cache: size:%d" % masks_cache_size)
if user_features is not None:
print(" features: 0x%X" % user_features)
# port print out
for iface in ndb.interfaces:
rep = vpl.info(iface.ifname, ifindex)
if rep is not None:
opts = ""
vpo = rep.get_attr("OVS_VPORT_ATTR_OPTIONS")
if vpo:
dpo = vpo.get_attr("OVS_TUNNEL_ATTR_DST_PORT")
if dpo:
opts += " tnl-dport:%s" % socket.ntohs(dpo)
print(
" port %d: %s (%s%s)"
% (
rep.get_attr("OVS_VPORT_ATTR_PORT_NO"),
rep.get_attr("OVS_VPORT_ATTR_NAME"),
OvsVport.type_to_str(rep.get_attr("OVS_VPORT_ATTR_TYPE")),
opts,
)
)
def main(argv):
nlmsg_atoms.ovskey = ovskey
nlmsg_atoms.ovsactions = ovsactions
# version check for pyroute2
prverscheck = pyroute2.__version__.split(".")
if int(prverscheck[0]) == 0 and int(prverscheck[1]) < 6:
print("Need to upgrade the python pyroute2 package to >= 0.6.")
sys.exit(0)
parser = argparse.ArgumentParser()
parser.add_argument(
"-v",
"--verbose",
action="count",
help="Increment 'verbose' output counter.",
default=0,
)
subparsers = parser.add_subparsers(dest="subcommand")
showdpcmd = subparsers.add_parser("show")
showdpcmd.add_argument(
"showdp", metavar="N", type=str, nargs="?", help="Datapath Name"
)
adddpcmd = subparsers.add_parser("add-dp")
adddpcmd.add_argument("adddp", help="Datapath Name")
adddpcmd.add_argument(
"-u",
"--upcall",
action="store_true",
help="Leave open a reader for upcalls",
)
adddpcmd.add_argument(
"-V",
"--versioning",
required=False,
help="Specify a custom version / feature string",
)
deldpcmd = subparsers.add_parser("del-dp")
deldpcmd.add_argument("deldp", help="Datapath Name")
addifcmd = subparsers.add_parser("add-if")
addifcmd.add_argument("dpname", help="Datapath Name")
addifcmd.add_argument("addif", help="Interface name for adding")
addifcmd.add_argument(
"-u",
"--upcall",
action="store_true",
help="Leave open a reader for upcalls",
)
addifcmd.add_argument(
"-t",
"--ptype",
type=str,
default="netdev",
choices=["netdev", "internal", "geneve", "vxlan"],
help="Interface type (default netdev)",
)
addifcmd.add_argument(
"-p",
"--dport",
type=int,
default=0,
help="Destination port (0 for default)"
)
addifcmd.add_argument(
"-l",
"--lwt",
type=bool,
default=True,
help="Use LWT infrastructure instead of vport (default true)."
)
delifcmd = subparsers.add_parser("del-if")
delifcmd.add_argument("dpname", help="Datapath Name")
delifcmd.add_argument("delif", help="Interface name for adding")
delifcmd.add_argument("-d",
"--dellink",
type=bool, default=False,
help="Delete the link as well.")
dumpflcmd = subparsers.add_parser("dump-flows")
dumpflcmd.add_argument("dumpdp", help="Datapath Name")
addflcmd = subparsers.add_parser("add-flow")
addflcmd.add_argument("flbr", help="Datapath name")
addflcmd.add_argument("flow", help="Flow specification")
addflcmd.add_argument("acts", help="Flow actions")
delfscmd = subparsers.add_parser("del-flows")
delfscmd.add_argument("flsbr", help="Datapath name")
subparsers.add_parser("psample-events")
args = parser.parse_args()
if args.verbose > 0:
if args.verbose > 1:
logging.basicConfig(level=logging.DEBUG)
ovspk = OvsPacket()
ovsdp = OvsDatapath()
ovsvp = OvsVport(ovspk)
ovsflow = OvsFlow()
ndb = NDB()
sys.setrecursionlimit(100000)
if args.subcommand == "psample-events":
PsampleEvent().read_samples()
if hasattr(args, "showdp"):
found = False
for iface in ndb.interfaces:
rep = None
if args.showdp is None:
rep = ovsdp.info(iface.ifname, 0)
elif args.showdp == iface.ifname:
rep = ovsdp.info(iface.ifname, 0)
if rep is not None:
found = True
print_ovsdp_full(rep, iface.index, ndb, ovsvp)
if not found:
msg = "No DP found"
if args.showdp is not None:
msg += ":'%s'" % args.showdp
print(msg)
elif hasattr(args, "adddp"):
rep = ovsdp.create(args.adddp, args.upcall, args.versioning, ovspk)
if rep is None:
print("DP '%s' already exists" % args.adddp)
else:
print("DP '%s' added" % args.adddp)
if args.upcall:
ovspk.upcall_handler(ovsflow)
elif hasattr(args, "deldp"):
ovsdp.destroy(args.deldp)
elif hasattr(args, "addif"):
rep = ovsdp.info(args.dpname, 0)
if rep is None:
print("DP '%s' not found." % args.dpname)
return 1
dpindex = rep["dpifindex"]
rep = ovsvp.attach(rep["dpifindex"], args.addif, args.ptype,
args.dport, args.lwt)
msg = "vport '%s'" % args.addif
if rep and rep["header"]["error"] is None:
msg += " added."
else:
msg += " failed to add."
if args.upcall:
if rep is None:
rep = ovsvp.reset_upcall(dpindex, args.addif, ovspk)
ovsvp.upcall_handler(ovsflow)
elif hasattr(args, "delif"):
rep = ovsdp.info(args.dpname, 0)
if rep is None:
print("DP '%s' not found." % args.dpname)
return 1
rep = ovsvp.detach(rep["dpifindex"], args.delif)
msg = "vport '%s'" % args.delif
if rep and rep["header"]["error"] is None:
msg += " removed."
else:
msg += " failed to remove."
if args.dellink:
ipr = pyroute2.iproute.IPRoute()
ipr.link("del", index=ipr.link_lookup(ifname=args.delif)[0])
elif hasattr(args, "dumpdp"):
rep = ovsdp.info(args.dumpdp, 0)
if rep is None:
print("DP '%s' not found." % args.dumpdp)
return 1
rep = ovsflow.dump(rep["dpifindex"])
for flow in rep:
print(flow.dpstr(True if args.verbose > 0 else False))
elif hasattr(args, "flbr"):
rep = ovsdp.info(args.flbr, 0)
if rep is None:
print("DP '%s' not found." % args.flbr)
return 1
flow = OvsFlow.ovs_flow_msg()
flow.parse(args.flow, args.acts, rep["dpifindex"])
ovsflow.add_flow(rep["dpifindex"], flow)
elif hasattr(args, "flsbr"):
rep = ovsdp.info(args.flsbr, 0)
if rep is None:
print("DP '%s' not found." % args.flsbr)
ovsflow.del_flows(rep["dpifindex"])
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv))
Reference in New Issue Copy Permalink