ifstate 1.13.7__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

libifstate/link/base.py

@@ -1,4 +1,4 @@
-from libifstate.util import logger, IfStateLogging, LinkDependency
+from libifstate.util import logger, format_ether_address, IfStateLogging, LinkDependency, IDENTIFY_LOOKUPS
 from libifstate.exception import ExceptionCollector, LinkTypeUnknown, NetnsUnknown, netlinkerror_classes
 from libifstate.brport import BRPort
 from libifstate.routing import RTLookups
@@ -129,7 +129,7 @@ class Link(ABC):
         return super().__new__(GenericLink)
         #raise LinkTypeUnknown()
 
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         self.ifstate = ifstate
         self.netns = netns
         self.cap_create = True
@@ -139,6 +139,7 @@ class Link(ABC):
         }
         self.settings.update(link)
         self.ethtool = None
+        self.hooks = hooks
         self.vrrp = vrrp
         if brport:
             self.brport = BRPort(netns, name, brport)
@@ -154,22 +155,17 @@ class Link(ABC):
         self.link_ref = LinkDependency(name, self.netns.netns)
 
         # prepare link registry search filters
-        if 'businfo' in self.settings:
-            self.settings['businfo'] = self.settings['businfo'].lower()
-            self.link_registry_search_args.append({
-                'kind': self.settings['kind'],
-                'businfo': self.settings['businfo'],
-            })
-
-        if 'permaddr' in self.settings:
-            self.settings['permaddr'] = self.settings['permaddr'].lower()
-            self.link_registry_search_args.append({
-                'kind': self.settings['kind'],
-                'permaddr': self.settings['permaddr'],
-            })
+        if identify:
+            search_args = {}
+            for attr in IDENTIFY_LOOKUPS.keys():
+                if attr in identify:
+                    search_args[attr] = identify[attr]
+            if search_args:
+                search_args['kind'] = self.settings['kind']
+                self.link_registry_search_args.append(search_args)
 
         if 'address' in self.settings and self.settings['kind'] == 'physical':
-            self.settings['address'] = self.settings['address'].lower()
+            self.settings['address'] = format_ether_address(self.settings['address'])
             self.link_registry_search_args.append({
                 'kind': self.settings['kind'],
                 'address': self.settings['address'],
@@ -249,11 +245,8 @@ class Link(ABC):
             return None
 
     def get_if_attr(self, key):
-        if key in ["state", "permaddr", "businfo"]:
-            if key in self.iface:
-                return self.iface[key]
-            else:
-                return None
+        if key == "state":
+            return self.iface.get(key)
 
         if key in self.attr_map:
             return self._drill_attr(self.iface, self.attr_map[key])
@@ -522,13 +515,6 @@ class Link(ABC):
         if self.idx is not None:
             self.iface = item.netns.ipr.get_link(self.idx)
         if self.idx is not None and self.iface is not None:
-            permaddr = item.netns.ipr.get_permaddr(self.iface.get_attr('IFLA_IFNAME'))
-            if not permaddr is None:
-                self.iface['permaddr'] = permaddr
-            businfo = item.netns.ipr.get_businfo(self.iface.get_attr('IFLA_IFNAME'))
-            if not businfo is None:
-                self.iface['businfo'] = businfo
-
             # check for ifname collisions
             idx = next(iter(self.netns.ipr.link_lookup(
                 ifname=self.settings['ifname'])), None)
@@ -631,6 +617,9 @@ class Link(ABC):
                                 if not isinstance(err, netlinkerror_classes):
                                     raise
                                 excpts.add('set', err, state=state)
+
+                    # get kernel state
+                    self.iface = self.netns.ipr.get_link(self.idx)
             except Exception as err:
                 if not isinstance(err, netlinkerror_classes):
                     raise
@@ -743,7 +732,7 @@ class Link(ABC):
             if do_apply:
                 # temp. remove special settings
                 skipped_settings = {}
-                for setting in ['state', 'peer', 'kind', 'businfo', 'permaddr']:
+                for setting in ['state', 'peer', 'kind']:
                     if setting in self.settings:
                         skipped_settings[setting] = self.settings.pop(setting)
 
@@ -838,6 +827,9 @@ class Link(ABC):
             else:
                 logger.log_ok('link')
 
+            # update kernel state
+            self.iface = self.netns.ipr.get_link(self.idx)
+
     def depends(self):
         deps = []
 
@@ -900,5 +892,5 @@ class Link(ABC):
 
 
 class GenericLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)

libifstate/link/physical.py

@@ -3,8 +3,8 @@ from libifstate.link.base import Link
 from libifstate.exception import LinkCannotAdd
 
 class PhysicalLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
         self.cap_create = False
         self.cap_ethtool = True
         self.ethtool = ethtool

libifstate/link/tun.py

@@ -6,14 +6,14 @@ from pwd import getpwnam
 from grp import getgrnam
 
 class TunLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         if 'tun_owner' in link and isinstance(link['tun_owner'], str):
             link['tun_owner'] = getpwnam(link['tun_owner'])[2]
 
         if 'tun_group' in link and isinstance(link['tun_group'], str):
             link['tun_group'] = getgrnam(link['tun_group'])[2]
 
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
         self.cap_create = bool(link.get('tun_persist'))
  
     def create(self, do_apply, sysctl, excpts, oper="add"):

libifstate/link/veth.py

@@ -3,14 +3,14 @@ from libifstate.link.base import Link
 from libifstate.exception import LinkCannotAdd, NetnsUnknown
 
 class VethLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         # use the bind_netns implementation to create the peer in the
         # target netns
         if 'peer_netns' in link:
             link['bind_netns'] = link['peer_netns']
             del(link['peer_netns'])
 
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
 
     def create(self, do_apply, sysctl, excpts, oper="add"):
         '''

libifstate/netns/__init__.py

@@ -1,10 +1,11 @@
-from libifstate.util import logger, IfStateLogging, IPRouteExt, NetNSExt, root_ipr
+from libifstate.util import logger, IfStateLogging, IPRouteExt, NetNSExt, root_ipr, root_iw, IDENTIFY_LOOKUPS
 from libifstate.sysctl import Sysctl
 
 import atexit
 from copy import deepcopy
 import logging
 import pyroute2
+from pyroute2.netlink.exceptions import NetlinkError
 import re
 import secrets
 import shutil
@@ -13,6 +14,7 @@ import subprocess
 netns_name_map = {}
 netns_name_root = None
 netns_nsid_map = {}
+iw_ifindex_phy_map = {}
 
 @atexit.register
 def close_netns():
@@ -44,12 +46,27 @@ class NetNameSpace():
 
         if name is None:
             self.ipr = root_ipr
+            self.iw = root_iw
             self.mount = b''
         else:
             self.ipr = NetNSExt(name)
             netns_name_map[name] = self.ipr
+
+            # check for wireless phys
+            if root_iw:
+                pyroute2.netns.pushns(name)
+                self.iw = pyroute2.IW()
+                pyroute2.netns.popns()
+            else:
+                self.iw = None
+
             self.mount = name.encode("utf-8")
 
+        if self.iw is not None:
+            for ifname, ifdict in self.iw.get_interfaces_dict().items():
+                # ifIndex => phyIndex
+                iw_ifindex_phy_map[ifdict[0]] = ifdict[3]
+
     def __deepcopy__(self, memo):
         '''
         Add custom deepcopy implementation to keep single IPRoute and NetNS instances.
@@ -59,7 +76,10 @@ class NetNameSpace():
         memo[id(self)] = result
         for k, v in self.__dict__.items():
             if k == 'ipr':
-                setattr(result, k, v)
+                if self.netns is None:
+                    setattr(result, k, IPRouteExt())
+                else:
+                    setattr(result, k, NetNSExt(self.netns))
             else:
                 setattr(result, k, deepcopy(v, memo))
         return result
@@ -223,8 +243,16 @@ class LinkRegistryItem():
             self.attributes['kind'] = linkinfo.get_attr('IFLA_INFO_KIND')
         else:
             self.attributes['kind'] = "physical"
-            self.attributes['businfo'] = self.netns.ipr.get_businfo(self.attributes['ifname'])
-            self.attributes['permaddr'] = link.get_attr('IFLA_PERM_ADDRESS')
+
+        # add iw phy for wireless interfaces
+        if link['index'] in iw_ifindex_phy_map:
+            self.attributes['wiphy'] = iw_ifindex_phy_map[link['index']]
+
+        # add identify attributes
+        for attr, lookup in IDENTIFY_LOOKUPS.items():
+            value = lookup(netns, link)
+            if value is not None:
+                self.attributes[attr] = value
 
     def __ipr_link(self, command, **kwargs):
         logger.debug("ip link set netns={} {}".format(
@@ -271,7 +299,14 @@ class LinkRegistryItem():
             # ToDo
             self.update_ifname( self.registry.get_random_name('__netns__') )
 
-        self.__ipr_link('set', index=self.attributes['index'], net_ns_fd=netns_name)
+        if self.attributes.get('wiphy') is not None:
+            # move phy instead of iface for wireless devices
+            if netns.netns is None:
+                self.netns.iw.set_wiphy_netns_by_pid(self.attributes['wiphy'], 1)
+            else:
+                self.netns.iw.set_wiphy_netns_by_pid(self.attributes['wiphy'], netns.ipr.child)
+        else:
+            self.__ipr_link('set', index=self.attributes['index'], net_ns_fd=netns_name)
         self.netns = netns
         self.attributes['index'] = next(iter(self.netns.ipr.link_lookup(ifname=self.attributes['ifname'])), None)
 

libifstate/parser/base.py

@@ -6,7 +6,6 @@ from copy import deepcopy
 
 class Parser(ABC):
     _default_lo_link = {
-        'name': 'lo',
         'addresses': [
             '127.0.0.1/8',
             '::1/128',
@@ -18,79 +17,96 @@ class Parser(ABC):
         }
     }
     _default_ifstates = {
-        'ignore': {
-            'ipaddr_builtin': [
-                'fe80::/10'
-            ],
-            'ipaddr_dynamic': True,
-            'ifname_builtin': [
-                r'^br-[\da-f]{12}',
-                r'^docker\d+',
-                r'^ppp\d+$',
-                r'^veth',
-                r'^virbr\d+',
-                r'^vrrp\d*\.\d+$'
-            ],
-            'fdb_builtin': [
-                r'^33:33:',
-                r'^01:00:5e:'
-            ],
-            'routes_builtin': [
-                {'proto': 1},
-                {'proto': 2},
-                {'proto': 8},
-                {'proto': 9},
-                {'proto': 10},
-                {'proto': 11},
-                {'proto': 12},
-                {'proto': 13},
-                {'proto': 14},
-                {'proto': 15},
-                {'proto': 16},
-                {'proto': 18},
-                {'proto': 42},
-                {'proto': 186},
-                {'proto': 187},
-                {'proto': 188},
-                {'proto': 189},
-                {'proto': 192},
-                {'to': 'ff00::/8'},
-            ],
-            'rules_builtin': [
-                {'proto': 1},
-                {'proto': 2},
-                {'proto': 8},
-                {'proto': 9},
-                {'proto': 10},
-                {'proto': 11},
-                {'proto': 12},
-                {'proto': 13},
-                {'proto': 14},
-                {'proto': 15},
-                {'proto': 16},
-                {'proto': 18},
-                {'proto': 42},
-                {'proto': 186},
-                {'proto': 187},
-                {'proto': 188},
-                {'proto': 189},
-                {'proto': 192},
-            ],
-        },
-        'cshaper': {
-            'default': {
-                'egress_qdisc': {
-                    'kind': 'cake',
-                    'handle': '1:',
-                },
-                'ingress_qdisc': {
-                    'kind': 'cake',
-                    'handle': '1:',
-                },
-                'ingress_ifname': {
-                    'search': r'^\D{1,3}',
-                    'replace': 'ifb',
+        'parameters': {
+            'cshaper': {
+                'default': {
+                    'egress_qdisc': {
+                        'kind': 'cake',
+                        'handle': '1:',
+                    },
+                    'ingress_qdisc': {
+                        'kind': 'cake',
+                        'handle': '1:',
+                    },
+                    'ingress_ifname': {
+                        'search': r'^\D{1,3}',
+                        'replace': 'ifb',
+                    }
+                }
+            },
+            'defaults_builtin': [
+                {
+                    'match': [
+                        {'ifname': ''}
+                    ],
+                    'clear_addresses': True,
+                    'clear_fdb': True,
+                    'clear_neighbours': True,
+                    'clear_tc': True,
+                    'link': {
+                        'state': 'down',
+                        'master': None
+                    }
                 }
+            ],
+            'ignore': {
+                'ipaddr_builtin': [
+                    'fe80::/10'
+                ],
+                'ipaddr_dynamic': True,
+                'ifname_builtin': [
+                    r'^br-[\da-f]{12}',
+                    r'^docker\d+',
+                    r'^ppp\d+$',
+                    r'^veth',
+                    r'^virbr\d+',
+                    r'^vrrp\d*\.\d+$'
+                ],
+                'fdb_builtin': [
+                    r'^33:33:',
+                    r'^01:00:5e:'
+                ],
+                'routes_builtin': [
+                    {'proto': 1},
+                    {'proto': 2},
+                    {'proto': 8},
+                    {'proto': 9},
+                    {'proto': 10},
+                    {'proto': 11},
+                    {'proto': 12},
+                    {'proto': 13},
+                    {'proto': 14},
+                    {'proto': 15},
+                    {'proto': 16},
+                    {'proto': 18},
+                    {'proto': 42},
+                    {'proto': 186},
+                    {'proto': 187},
+                    {'proto': 188},
+                    {'proto': 189},
+                    {'proto': 192},
+                    {'to': 'ff00::/8'},
+                ],
+                'rules_builtin': [
+                    {'proto': 1},
+                    {'proto': 2},
+                    {'proto': 8},
+                    {'proto': 9},
+                    {'proto': 10},
+                    {'proto': 11},
+                    {'proto': 12},
+                    {'proto': 13},
+                    {'proto': 14},
+                    {'proto': 15},
+                    {'proto': 16},
+                    {'proto': 18},
+                    {'proto': 42},
+                    {'proto': 186},
+                    {'proto': 187},
+                    {'proto': 188},
+                    {'proto': 189},
+                    {'proto': 192},
+                ],
             }
         }
     }
@@ -114,11 +130,11 @@ class Parser(ABC):
 
     def _update_lo(self, cfg):
         if 'interfaces' in cfg:
-            lo = next((idx for idx, iface in enumerate(cfg['interfaces']) if iface['name'] == 'lo'), None)
-            if lo is not None:
-                cfg['interfaces'][lo] = self.merge(deepcopy(Parser._default_lo_link), cfg['interfaces'][lo])
+            if 'lo' in cfg['interfaces']:
+                cfg['interfaces']['lo'] = self.merge(
+                    deepcopy(Parser._default_lo_link), cfg['interfaces']['lo'])
             else:
-                cfg['interfaces'].append(Parser._default_lo_link)
+                cfg['interfaces']['lo'] = Parser._default_lo_link
 
     def config(self):
         # merge builtin defaults with config
@@ -126,7 +142,7 @@ class Parser(ABC):
 
         # 'ignore' should still be an object
         try:
-            iter(cfg["ignore"])
+            iter(cfg["parameters"]["ignore"])
         except TypeError:
             raise ParserValidationError("$.ignore: is not of type 'object'")
 
@@ -136,18 +152,25 @@ class Parser(ABC):
             self._update_lo(cfg['namespaces'][namespace])
 
         # merge builtin defaults
-        for k in list(cfg["ignore"]):
+        if "defaults" in cfg["parameters"]:
+            cfg["parameters"]["defaults"].extend(cfg["parameters"]["defaults_builtin"])
+        else:
+            cfg["parameters"]["defaults"] = cfg["parameters"]["defaults_builtin"]
+        del cfg["parameters"]["defaults_builtin"]
+
+        # merge builtin ignore lists
+        for k in list(cfg["parameters"]["ignore"]):
             if k.endswith("_builtin"):
                 n = k[:-8]
-                if n in cfg["ignore"]:
+                if n in cfg["parameters"]["ignore"]:
                     try:
-                        cfg["ignore"][n] += cfg["ignore"][k]
+                        cfg["parameters"]["ignore"][n] += cfg["parameters"]["ignore"][k]
                     except TypeError:
                         raise ParserValidationError("$.ignore.{}: is not of type '{}'".format(
-                            n, type(cfg["ignore"][k]).__name__))
+                            n, type(cfg["parameters"]["ignore"][k]).__name__))
                 else:
-                    cfg["ignore"][n] = cfg["ignore"][k]
-                del(cfg["ignore"][k])
+                    cfg["parameters"]["ignore"][n] = cfg["parameters"]["ignore"][k]
+                del (cfg["parameters"]["ignore"][k])
 
         return cfg
 

libifstate/routing/__init__.py

@@ -1,6 +1,6 @@
 from libifstate.util import logger, IfStateLogging
 from libifstate.exception import RouteDuplicate, netlinkerror_classes
-from ipaddress import ip_address, ip_network, IPv6Network
+from ipaddress import ip_address, ip_interface, ip_network, IPv6Network
 from pyroute2.netlink.rtnl.fibmsg import FR_ACT_VALUES
 from pyroute2.netlink.rtnl import rt_type
 import collections.abc
@@ -284,8 +284,8 @@ class Tables(collections.abc.Mapping):
                     idx = next(
                         iter(self.netns.ipr.link_lookup(ifname=ignore[attr])), None)
                     if idx is None:
-                        logger.debug("{} '{}' is unknown".format(attr, ignore[attr]))
-                        del ignore[attr]
+                        logger.debug("{} '{}' is unknown, skipping ignore".format(attr, ignore[attr]))
+                        continue
                     else:
                         ignore[attr] = idx
             parsed.append(ignore)
@@ -321,7 +321,7 @@ class Tables(collections.abc.Mapping):
                 continue
 
             if route['dst_len'] > 0:
-                dst = ip_network(
+                dst = ip_interface(
                     '{}/{}'.format(route.get_attr('RTA_DST'), route['dst_len'])).with_prefixlen
             elif route['family'] == AF_INET:
                 dst = ip_network('0.0.0.0/0').with_prefixlen
@@ -546,13 +546,18 @@ class Rules():
                 'tos': rule['tos'],
             }
 
-            if rule['dst_len'] > 0:
-                ru['dst'] = rule.get_attr('FRA_DST')
-                ru['dst_len'] = rule['dst_len']
+            # add source and destination ip spaces even if they are not given by pyroute2
+            # as the user might specify something like "from: ::/0" explicitly which would not
+            # be present on a krule (because default values are ommited by pyroute2) and therefore
+            # would not match, even though it is the same rule
+            # if the user doesn't specify 'from' or 'to', these fields are just ignored because
+            # rule_matches is instructed to only check fields that are present on the config rule,
+            # meaning that these just get ignored
+            ru['dst'] = rule.get_attr('FRA_DST', default=("::" if rule['family'] == AF_INET6 else "0.0.0.0"))
+            ru['dst_len'] = rule['dst_len']
 
-            if rule['src_len'] > 0:
-                ru['src'] = rule.get_attr('FRA_SRC')
-                ru['src_len'] = rule['src_len']
+            ru['src'] = rule.get_attr('FRA_SRC', default=("::" if rule['family'] == AF_INET6 else "0.0.0.0"))
+            ru['src_len'] = rule['src_len']
 
             for field in ['iifname', 'oifname', 'fwmark', 'ip_proto']:
                 value = rule.get_attr('FRA_{}'.format(field.upper()))
@@ -593,7 +598,7 @@ class Rules():
                 del rule['protocol']
 
             if 'src_len' in rule and rule['src_len'] > 0:
-                rule['from'] = ip_network(
+                rule['from'] = ip_interface(
                     '{}/{}'.format(rule['src'], rule['src_len'])).with_prefixlen
 
             for key in ['src', 'src_len', 'tos', 'protocol']:
@@ -609,32 +614,51 @@ class Rules():
 
         # get rules that are currently in the kernels list
         krules = self.kernel_rules()
+
+        # loop over all rules that are wanted by the config
         for rule in self.rules:
             log_str = '#{}'.format(rule['priority'])
+
+            if rule.get('family', None) == AF_INET6:
+                log_str += " (inet6)"
+            elif rule.get('family', None) == AF_INET:
+                log_str += " (inet)"
+
             if self.netns.netns != None:
                 log_str += "[netns={}]".format(self.netns.netns)
 
+            vrrp_matched = vrrp_match(rule, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
+            # 'found' indicates whether the rule wanted by the config was found
+            # in the kernels rules. if not, it is going to be added below
             found = False
-            matched = vrrp_match(rule, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
             for i, krule in enumerate(krules):
                 if rule_matches(
                     rule,
                     krule,
                     # skip helper attrs like _vrrp
+                    # note that rule_matches it told to only check fields that are
+                    # present on the config rule, so additional ones from the krule
+                    # just get ignored
                     [key for key in rule.keys() if key[0] != '_']
                 ):
                     found = True
 
-                    # remove kernel routes due to vrrp_match
-                    if matched != VRRP_MATCH_DISABLE:
+                    # we've just confirmed that this krule matches a rule
+                    # that is wanted by the config so we delete it from the
+                    # krules because any that remain in krule are unwanted
+                    # and get deleted below
+                    # EXCEPT if vrrp tells us to leave it be
+                    if vrrp_matched != VRRP_MATCH_DISABLE:
                         del krules[i]
 
                     break
 
-            if matched not in [VRRP_MATCH_IGNORE, VRRP_MATCH_DISABLE]:
+            if vrrp_matched not in [VRRP_MATCH_IGNORE, VRRP_MATCH_DISABLE]:
                 if found:
+                    # rule already exists
                     logger.log_ok(log_str)
                 else:
+                    # rule doesn't exist, add it
                     logger.log_add(log_str)
 
                     logger.debug("ip rule add: {}".format(
@@ -647,7 +671,12 @@ class Rules():
                             raise
                         logger.warning('rule setup failed: {}'.format(err.args[1]))
 
+        # at this point all wanted rules have been deleted from the krules list,
+        # leaving the rest to be deleted here (see 'del krules[i]' above)
         for rule in krules:
+
+            # if this rule falls into the ignored ones (like the ones set by the kernel itself by default)
+            # we will ignore it and continue
             ignore = False
             for irule in ignores:
                 if 'proto' in irule:
@@ -659,9 +688,26 @@ class Rules():
             if ignore:
                 continue
 
-            logger.log_del('#{}'.format(rule['priority']))
+            log_str = '#{}'.format(rule['priority'])
+
+            if rule.get('family', None) == AF_INET6:
+                log_str += " (inet6)"
+            elif rule.get('family', None) == AF_INET:
+                log_str += " (inet)"
+
+            logger.log_del(log_str)
+
             try:
                 if do_apply:
+                    # for some reason pyroute2 raises an exception when
+                    # we pass an address like "0.0.0.0" or "::" with an
+                    # 'src_len' or 'dst_len' of 0.
+                    # using this as a workaround:
+                    if rule['src_len'] == 0:
+                        del rule['src']
+                    if rule['dst_len'] == 0:
+                        del rule['dst']
+
                     self.netns.ipr.rule('del', **rule)
             except Exception as err:
                 if not isinstance(err, netlinkerror_classes):