| #!/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)) |
