"""Routes from ``ip route show``, one address family at a time.""" from __future__ import annotations import re from collections.abc import Iterator from typing import NamedTuple #: The command per family. ``ip -6 route show`` names its default route ``default`` #: as well, so only the command a line came from says which family it is (#6). IP_ROUTE_COMMANDS = {"ipv4": "ip -4 route show", "ipv6": "ip -6 route show"} _DEFAULT = {"ipv4": "0.0.0.0/0", "ipv6": "::/0"} _HOST_PREFIX = {"ipv4": "/32", "ipv6": "/128"} #: The route types ``ip route`` prints in front of the destination; a unicast route #: carries none (#57). _ROUTE_TYPES = frozenset( { "unicast", "local", "broadcast", "anycast", "multicast", "blackhole", "unreachable", "prohibit", "throw", "nat", "xresolve", } ) #: Route types that send nothing out of an interface: no next hop, and no outgoing #: interface either, though IPv6 names ``lo`` for them. _NO_FORWARDING = frozenset({"blackhole", "unreachable", "prohibit", "throw"}) #: The line a multipath route's next hops start with, one each, after the route. _NEXTHOP = "nexthop" #: ``via 192.0.2.1``, or with the gateway's family in front: ``via inet6 fe80::1`` for an #: IPv4 route with an IPv6 next hop (RFC 8950, #65). _VIA = re.compile(r"via\s+(?:inet6?\s+)?(\S+)") _DEV = re.compile(r"dev\s+(\S+)") _PROTO = re.compile(r"proto\s+(\S+)") _METRIC = re.compile(r"metric\s+(\d+)") class IpRoute(NamedTuple): """One route of ``ip route show``; a multipath route is one per next hop.""" network: str proto: str nexthop: str iface: str metric: int route_type: str = "unicast" @property def attributes(self) -> dict[str, str]: """NAPALM's ``protocol_attributes`` for this route: its type, unless unicast.""" return {} if self.route_type == "unicast" else {"type": self.route_type} def parse_ip_route(out: str, family: str) -> Iterator[IpRoute]: """The routes in *out*, the output of ``IP_ROUTE_COMMANDS[family]``.""" route = "" hops: list[str] = [] for line in out.splitlines(): line = line.strip() if not line or line.startswith("#"): continue if line.split(None, 1)[0] == _NEXTHOP: hops.append(line) continue if route: yield from _routes(route, hops, family) route, hops = line, [] if route: yield from _routes(route, hops, family) def with_length(prefix: str) -> str: """*prefix* with a prefix length: a host route without one is ``/32`` or ``/128`` by the address's family (#64).""" if "/" in prefix: return prefix return prefix + _HOST_PREFIX["ipv6" if ":" in prefix else "ipv4"] def _routes(line: str, hops: list[str], family: str) -> Iterator[IpRoute]: """The route *line* with its multipath next-hop lines *hops*: one per next hop.""" words = line.split() route_type = words.pop(0) if words[0] in _ROUTE_TYPES and len(words) > 1 else "unicast" network = _DEFAULT[family] if words[0] == "default" else words[0] if "/" not in network: network += _HOST_PREFIX[family] proto = _first(_PROTO, line) or "kernel" metric = int(_first(_METRIC, line) or 0) if route_type in _NO_FORWARDING: yield IpRoute(network, proto, "", "", metric, route_type) return for hop in hops or [line]: yield IpRoute(network, proto, _first(_VIA, hop), _first(_DEV, hop), metric, route_type) def _first(pattern: re.Pattern[str], line: str) -> str: match = pattern.search(line) return match.group(1) if match else ""