member-console/internal/dnsname/dnsname.go

// Package dnsname holds the DNS shape rules and normalization the console
// applies to every name it stores or serves: label/FQDN validation (RFC 1035
// §2.3.1 as amended by RFC 1123 §2.1, and the §2.3.4 length limit),
// normalization, and the label reversal the registry indexes subtrees by.
//
// It is a leaf: standard library only. internal/server and internal/domains
// both consume it, which is what lets internal/domains stay out of
// internal/server's import graph (internal/server imports internal/domains
// for Config wiring, so the reverse edge cannot exist).
//
// Validators return a user-facing message, or "" when the name is valid.
package dnsname

import (
	"fmt"
	"regexp"
	"strings"
)

// validLabel enforces the DNS label rules from RFC 1035 §2.3.1 (as amended
// by RFC 1123 §2.1): lowercase alphanumeric, may contain hyphens in the
// middle, must start and end with a letter or number. 1-63 chars.
//
// Callers must normalize input (see Normalize) before matching, as this
// pattern only matches lowercase.
var validLabel = regexp.MustCompile(`^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$`)

// Normalize applies the console-wide name normalization: trim surrounding
// whitespace, lowercase, and strip one trailing dot (the root label of an
// absolute name). Every stored or compared name passes through this first.
func Normalize(name string) string {
	return strings.TrimSuffix(strings.TrimSpace(strings.ToLower(name)), ".")
}

// ReverseLabels returns name with its labels in reverse order —
// "alice.wiki.cafe" becomes "cafe.wiki.alice". Reversed form turns a
// subtree into a string prefix, so descendant lookups become prefix scans
// over a text_pattern_ops index. Callers pass normalized names; the
// reversal itself does not normalize.
func ReverseLabels(name string) string {
	labels := strings.Split(name, ".")
	for i, j := 0, len(labels)-1; i < j; i, j = i+1, j-1 {
		labels[i], labels[j] = labels[j], labels[i]
	}
	return strings.Join(labels, ".")
}

// ValidateDNSLabel validates a single DNS label. It checks length before
// pattern to provide specific error messages per RFC 1035 §2.3.1.
func ValidateDNSLabel(name string) string {
	if len(name) > 63 {
		return "Site name exceeds the 63-character limit"
	}
	if !validLabel.MatchString(name) {
		return "Site name may only contain lowercase letters, numbers, and hyphens, and must start and end with a letter or number"
	}
	return ""
}

// ValidateFQDN checks that the assembled FQDN (label + "." + parent) does
// not exceed 253 characters per RFC 1035 §2.3.4. The 63-char label limit
// already prevents overflow for any reasonable parent domain; this is a
// defense-in-depth measure.
func ValidateFQDN(label, parent string) string {
	// FQDN = label + "." + parent
	fqdnLen := len(label) + 1 + len(parent)
	if fqdnLen > 253 {
		return fmt.Sprintf("The full domain name (%s.%s) exceeds the 253-character limit", label, parent)
	}
	return ""
}

// ValidateExternalFQDN checks a member-supplied external (bring-your-own)
// domain name: a fully-qualified name of at least two labels, each
// satisfying the RFC 1035 §2.3.1 label rules (as amended by RFC 1123 §2.1),
// within the RFC 1035 §2.3.4 253-character presentation limit. Names equal
// to or inside any of operatorRoots are rejected — those are creatable only
// through the hosted path, where label policy and quota gating apply. Pass
// a nil or empty operatorRoots to check shape only. Callers must pass a
// normalized name (see Normalize).
func ValidateExternalFQDN(domain string, operatorRoots []string) string {
	if domain == "" {
		return "Domain is required"
	}
	if len(domain) > 253 {
		return fmt.Sprintf("The domain name (%s) exceeds the 253-character limit", domain)
	}
	labels := strings.Split(domain, ".")
	if len(labels) < 2 {
		return "Enter a full domain name (e.g., wiki.example.org)"
	}
	for _, label := range labels {
		if !validLabel.MatchString(label) {
			return "Domain labels may only contain lowercase letters, numbers, and hyphens, and must start and end with a letter or number"
		}
	}
	for _, root := range operatorRoots {
		if root == "" {
			continue
		}
		if domain == root || strings.HasSuffix(domain, "."+root) {
			return fmt.Sprintf("Names under %s are created as regular sites, not custom domains", root)
		}
	}
	return ""
}