net.ip-classify

def classify_ip(address: str) -> IpClassification

@dataclass(frozen=True)
class IpClassification:
    """Which special-purpose block an address falls in, the most specific one."""

    #: canonical text
    address: str
    #: 4 or 6
    version: int
    category: IpCategory
    #: the IANA registry's name for the block, or Global unicast
    name: str
    #: the matching block, null for global
    block: Optional[str]
    #: the document that assigned it
    rfc: Optional[str]
    #: as the IANA registry says; null where it says N/A
    globally_reachable: Optional[bool]

IpCategory = Literal["unspecified", "this-network", "loopback", "private", "shared", "link-local", "multicast", "documentation", "benchmarking", "reserved", "broadcast", "protocol", "translation", "ipv4-mapped", "discard", "global"]

from fune.net.ip_classify import classify_ip  # net.ip-classify@^1

from .net_cidr import cidr_contains  ← from net.cidr ^1.0.0 · built alongside by fune
from .net_ip_classify_data import SPECIAL_BLOCKS  ← this capability’s own data, compiled from data/special-purpose.json into the same file by fune build
from .net_ip_classify_types import IpClassification
from .net_ipv4 import is_ipv4  ← from net.ipv4 ^1.0.0 · built alongside by fune
from .net_ipv6 import format_ipv6, is_ipv6, parse_ipv6  ← from net.ipv6 ^1.0.0 · built alongside by fune


def classify_ip(address: str) -> IpClassification:
    """Which special-purpose block an address is in.

    From the IANA IPv4 and IPv6 Special-Purpose Address Registries (RFC 6890)
    plus the multicast ranges. The most specific block wins: 192.0.0.9 is Port
    Control Protocol Anycast (globally reachable), not the /24 of IETF
    assignments around it (not). An address in no block is "global".
    """
    if is_ipv4(address):
        version = 4
        canonical = address
    elif is_ipv6(address):
        version = 6
        canonical = format_ipv6(parse_ipv6(address))
    else:
        raise ValueError('"%s" is not an IPv4 or IPv6 address' % (address,))
    best = None
    best_prefix = -1
    for row in SPECIAL_BLOCKS:
        if (":" in row.block) != (version == 6):
            continue
        if not cidr_contains(row.block, canonical):
            continue
        prefix = int(row.block[row.block.index("/") + 1:])
        if prefix > best_prefix:
            best, best_prefix = row, prefix
    if best is None:
        return IpClassification(
            address=canonical, version=version, category="global", name="Global unicast",
            block=None, rfc=None, globally_reachable=True,
        )
    return IpClassification(
        address=canonical, version=version, category=best.category, name=best.name,
        block=best.block, rfc=best.rfc, globally_reachable=best.globally_reachable,
    )

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and its 3 dependencies, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add net.ip-classify

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./net.ip-classify-1.0.0-python.fune, or fetch it from a terminal with fune pull net.ip-classify@1.0.0:python.

The whole function, every language, is one file too: net.ip-classify-1.0.0.fune, 28,917 bytes, sha256 597f539abc40a7ef8f254dd3c14b52974a0a93ad2d1d5931dc716c99f023dd92. It installs into a project of any language.

# fune: before net.ip-classify

# fune: after net.ip-classify

# fune: replace net.cidr in net.ip-classify
# fune: replace net.ipv4 in net.ip-classify
# fune: replace net.ipv6 in net.ip-classify

# fune: step net.ip-classify after <n|label>

More from the author

The rules are data (`data/special-purpose.json`), one row per block of the IANA special-purpose registries, with the registry's own name, RFC and "Globally Reachable" column. An address is matched against every block of its family and **the most specific (longest prefix) wins**, as the registry intends: `192.0.0.9` is Port Control Protocol Anycast (globally reachable), not the surrounding `192.0.0.0/24` IETF assignments (not reachable). An address in no block is `global`, name `Global unicast`, reachable.

`category` is this capability's grouping of the registry's names, so callers can branch on a closed set; `name`, `block` and `rfc` say exactly which row matched. `globallyReachable` is the registry's column, null where it says N/A (Teredo, 6to4, deprecated blocks) and for the multicast ranges, which the special-purpose registries do not list.

## Edge cases

- IPv6 is returned in RFC 5952 canonical form (`FE80::0001` gives `fe80::1`). - An IPv4-mapped address (`::ffff:192.168.1.1`) is `ipv4-mapped`; it is not classified as the IPv4 address inside it. Classify the IPv4 part yourself if that is what you mean. - `global` for IPv6 means "in no special-purpose block", which includes space IANA has not allocated yet. - Text follows `net.ipv4` / `net.ipv6` strictly: no leading zeros, zone ids or prefixes.

## Sources (checked 2026-09-26 against the registries' CSV exports)

- IANA IPv4 Special-Purpose Address Registry, https://www.iana.org/assignments/iana-ipv4-special-registry/ (RFC 6890, RFC 8190). All 25 rows, including 192.88.99.2/32 (6a44 relay) and the two NAT64/DNS64 discovery /32s listed as one row there. - IANA IPv6 Special-Purpose Address Registry, https://www.iana.org/assignments/iana-ipv6-special-registry/. All 26 rows, including 100:0:0:1::/64 (RFC 9780), 3fff::/20 (RFC 9637) and 5f00::/16 (RFC 9602). - IPv4 multicast 224.0.0.0/4: RFC 5771 (IANA Guidelines for IPv4 Multicast Address Assignments). IPv6 multicast ff00::/8: RFC 4291 section 2.7.

When the registry changes, publish a new version with the new rows.

Files