net.hostname-validate

def validate_hostname(text: str) -> HostnameValidation

@dataclass(frozen=True)
class HostnameValidation:
    """Whether the text is a usable host name, and its normal form."""

    valid: bool
    #: lower-case, trailing dot removed
    hostname: Optional[str]
    #: why it is not valid
    reason: Optional[str]
    #: how many dot-separated labels the text has
    labels: int

from fune.net.hostname_validate import validate_hostname  # net.hostname-validate@^1

import re

from .net_hostname_validate_types import HostnameValidation

ALLOWED = re.compile(r"[A-Za-z0-9.-]*")
DIGITS = re.compile(r"[0-9]+")


def validate_hostname(text: str) -> HostnameValidation:
    """Check a host name against the RFC 1123 / RFC 952 rules and normalise it:
    lower-case, one trailing dot (a fully qualified name) removed.

    Checks run in a fixed order and the first failure is the reason: empty,
    characters, total length, then each label in turn, then the top-level label.
    """
    if not isinstance(text, str):
        return HostnameValidation(valid=False, hostname=None, reason="not text", labels=0)
    name = text[:-1] if text.endswith(".") else text
    labels = [] if len(name) == 0 else name.split(".")

    def fail(reason: str) -> HostnameValidation:
        return HostnameValidation(valid=False, hostname=None, reason=reason, labels=len(labels))

    if len(name) == 0:
        return fail("empty")
    # Characters first: once the text is known to be ASCII, every language
    # counts its length the same way.
    if not ALLOWED.fullmatch(name):
        return fail("character other than a letter, digit, hyphen or dot")
    if len(name) > 253:
        return fail("longer than 253 characters")
    for label in labels:
        if len(label) == 0:
            return fail("empty label")
        if len(label) > 63:
            return fail("label longer than 63 characters")
        if label.startswith("-") or label.endswith("-"):
            return fail("label starts or ends with a hyphen")
    # RFC 3696 section 2: a top-level domain is never all-numeric, which keeps
    # 1.2.3.4 an address rather than a name.
    if DIGITS.fullmatch(labels[-1]):
        return fail("top-level label is all numeric")
    return HostnameValidation(valid=True, hostname=name.lower(), reason=None, labels=len(labels))

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, 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.hostname-validate

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

The whole function, every language, is one file too: net.hostname-validate-1.0.0.fune, 16,975 bytes, sha256 9576a43bfb084e52ba629fd752e619e549894cae29d493d149f1b1ff4f682255. It installs into a project of any language.

# fune: before net.hostname-validate

# fune: after net.hostname-validate

# fune: step net.hostname-validate after <n|label>

More from the author

The first rule that fails is the reason.

1. Not empty (`""` and `"."` are `empty`). 2. Only ASCII letters, digits, hyphens and dots. No underscores (allowed in some DNS record names such as `_sip._tcp`, never in a host name), no spaces, no trailing newline, nothing non-ASCII: an internationalised name must be converted to its `xn--` punycode form first. 3. At most 253 characters, not counting the trailing dot (RFC 1035 section 2.3.4 allows 255 octets on the wire, which is 253 characters of text). 4. Every label is 1 to 63 characters (RFC 1035 2.3.4) and does not start or end with a hyphen (RFC 952). A label may start with a digit: RFC 1123 section 2.1 relaxed RFC 952 on that point, so `3com.example` is fine. 5. The last label is not all digits (RFC 3696 section 2). This keeps `192.168.1.1` an address, not a name, so a caller can try the IP parsers first and fall back to this without ambiguity.

## Not checked

Whether the name resolves, whether its top-level domain exists, and the rules for other DNS record names (underscores, wildcards). `labels` is counted even when the name is invalid, from the text with one trailing dot removed.

Sources: RFC 952 (DoD Internet Host Table Specification), RFC 1123 section 2.1 (Requirements for Internet Hosts), RFC 1035 section 2.3.4 (size limits), RFC 3696 section 2 (Application Techniques for Checking and Transformation of Names).

Files