milestone 25: client names learned over reverse dns

src/local/reverse_name.zig

@@ -0,0 +1,204 @@
+//! Reverse DNS names and the hostname gate for learned client names
+//! (milestone 25). Pure: bytes in, bytes out — no `std.Io`, no clock, no
+//! sockets. Everything that queries a resolver or writes a row lives in
+//! `src/server/`.
+
+const std = @import("std");
+
+const address = @import("../platform/address.zig");
+
+const v4_suffix = "in-addr.arpa";
+const v6_suffix = "ip6.arpa";
+
+/// The v6 form is the longest: 32 nibbles, each followed by a dot, then
+/// `ip6.arpa`.
+pub const max_reverse_len: usize = 32 * 2 + v6_suffix.len;
+
+/// A PTR owner name is one label per byte (v4) or per nibble (v6), least
+/// significant first, under `in-addr.arpa` / `ip6.arpa`. Lowercase hex for v6,
+/// no trailing dot — the form `forward_zones.Zones.match` expects.
+///
+/// The tracker canonicalises an IPv4-mapped v6 address to `.ip4` before a
+/// `NetAddress` reaches here, so this function never sees one.
+pub fn reverseName(addr: address.NetAddress, buf: *[max_reverse_len]u8) []const u8 {
+    var w = std.Io.Writer.fixed(buf);
+    switch (addr) {
+        .ip4 => |b| {
+            w.print("{d}.{d}.{d}.{d}.{s}", .{ b[3], b[2], b[1], b[0], v4_suffix }) catch unreachable;
+        },
+        .ip6 => |b| {
+            std.debug.assert(!isIp4Mapped(b));
+            var i: usize = b.len;
+            while (i > 0) {
+                i -= 1;
+                const byte = b[i];
+                w.writeByte(hex_digits[byte & 0x0f]) catch unreachable;
+                w.writeByte('.') catch unreachable;
+                w.writeByte(hex_digits[byte >> 4]) catch unreachable;
+                w.writeByte('.') catch unreachable;
+            }
+            w.writeAll(v6_suffix) catch unreachable;
+        },
+    }
+    return w.buffered();
+}
+
+const hex_digits = "0123456789abcdef";
+
+fn isIp4Mapped(b: [16]u8) bool {
+    return std.mem.eql(u8, b[0..10], &[_]u8{0} ** 10) and b[10] == 0xff and b[11] == 0xff;
+}
+
+/// The gate every PTR target passes before it is stored, logged or displayed.
+/// The bytes come from whatever box the operator pointed a forward zone at, so
+/// nothing weaker is enough.
+///
+/// Accepts only `[a-z0-9._-]` after ASCII-lowercasing `A-Z`; labels are 1–63
+/// bytes and the whole name is at most 253; no label starts or ends with `-`.
+/// An empty label is rejected, which also rejects a trailing dot — `formatText`
+/// emits none, so one appearing means the reply was malformed.
+///
+/// Underscore is accepted because real DHCP hostnames carry it. Nothing else
+/// outside the set is.
+pub fn acceptHostname(text: []const u8) bool {
+    if (text.len == 0 or text.len > 253) return false;
+
+    var label_len: usize = 0;
+    var prev: u8 = 0;
+    for (text) |raw| {
+        const ch = std.ascii.toLower(raw);
+        if (ch == '.') {
+            if (label_len == 0) return false;
+            if (prev == '-') return false;
+            label_len = 0;
+            prev = ch;
+            continue;
+        }
+        if (label_len == 0 and ch == '-') return false;
+        if (!isHostByte(ch)) return false;
+        label_len += 1;
+        if (label_len > 63) return false;
+        prev = ch;
+    }
+    if (label_len == 0) return false;
+    if (prev == '-') return false;
+    return true;
+}
+
+fn isHostByte(ch: u8) bool {
+    return (ch >= 'a' and ch <= 'z') or (ch >= '0' and ch <= '9') or ch == '_' or ch == '-';
+}
+
+// ---------------------------------------------------------------------------
+// tests
+// ---------------------------------------------------------------------------
+
+const testing = std.testing;
+
+test "reverseName reverses the octets of a v4 address" {
+    var buf: [max_reverse_len]u8 = undefined;
+    try testing.expectEqualStrings(
+        "10.1.168.192.in-addr.arpa",
+        reverseName(try address.NetAddress.parse("192.168.1.10"), &buf),
+    );
+    try testing.expectEqualStrings(
+        "0.0.0.0.in-addr.arpa",
+        reverseName(try address.NetAddress.parse("0.0.0.0"), &buf),
+    );
+    try testing.expectEqualStrings(
+        "255.255.255.255.in-addr.arpa",
+        reverseName(try address.NetAddress.parse("255.255.255.255"), &buf),
+    );
+}
+
+test "reverseName writes the 32-nibble lowercase ip6.arpa form" {
+    var buf: [max_reverse_len]u8 = undefined;
+    try testing.expectEqualStrings(
+        "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.f.ip6.arpa",
+        reverseName(try address.NetAddress.parse("fd00::1"), &buf),
+    );
+    // Every nibble distinct, so a swapped high/low half would show.
+    try testing.expectEqualStrings(
+        "b.a.9.8.7.6.5.4.3.2.1.0.f.e.d.c.b.a.9.8.7.6.5.4.3.2.1.0.f.e.d.c.ip6.arpa",
+        reverseName(try address.NetAddress.parse("cdef:0123:4567:89ab:cdef:0123:4567:89ab"), &buf),
+    );
+}
+
+test "the v6 form is exactly max_reverse_len bytes and the v4 form is shorter" {
+    var buf: [max_reverse_len]u8 = undefined;
+    const v6 = reverseName(try address.NetAddress.parse("cdef:0123:4567:89ab:cdef:0123:4567:89ab"), &buf);
+    try testing.expectEqual(max_reverse_len, v6.len);
+    const v4 = reverseName(try address.NetAddress.parse("255.255.255.255"), &buf);
+    try testing.expect(v4.len < max_reverse_len);
+}
+
+test "an IPv4-mapped v6 literal is already canonical, so reverseName sees v4" {
+    var buf: [max_reverse_len]u8 = undefined;
+    try testing.expectEqualStrings(
+        "10.1.168.192.in-addr.arpa",
+        reverseName(try address.NetAddress.parse("::ffff:192.168.1.10"), &buf),
+    );
+}
+
+test "acceptHostname accepts and rejects ruling 4's table" {
+    // 254 bytes, every label within 63: only the total length rejects it.
+    const long_name = "a" ** 63 ++ "." ++ "a" ** 63 ++ "." ++ "a" ** 63 ++ "." ++ "a" ** 62;
+    try testing.expectEqual(@as(usize, 254), long_name.len);
+    const long_label = "a" ** 64;
+
+    const cases = [_]struct { text: []const u8, want: bool }{
+        .{ .text = "", .want = false },
+        .{ .text = long_name, .want = false },
+        .{ .text = long_label, .want = false },
+        .{ .text = "a b", .want = false },
+        .{ .text = "a\x00b", .want = false },
+        .{ .text = "héllo", .want = false },
+        .{ .text = "-x", .want = false },
+        .{ .text = "x-.y", .want = false },
+        .{ .text = "a..b", .want = false },
+        .{ .text = ".a", .want = false },
+        .{ .text = "a.", .want = false },
+        .{ .text = "nas-1.lan", .want = true },
+        .{ .text = "my_printer.home", .want = true },
+        .{ .text = "x", .want = true },
+    };
+    for (cases) |case| {
+        testing.expectEqual(case.want, acceptHostname(case.text)) catch |err| {
+            std.debug.print("acceptHostname(\"{s}\")\n", .{case.text});
+            return err;
+        };
+    }
+}
+
+test "a reverse name matches the forward zone declared over its reverse space" {
+    const forward_zones = @import("forward_zones.zig");
+
+    var zones = try forward_zones.Zones.build(testing.allocator, &.{
+        .{ .zone = "168.192.in-addr.arpa", .resolver = "udp://192.168.1.1:53" },
+        .{ .zone = "0.0.d.f.ip6.arpa", .resolver = "udp://[fd00::1]:53" },
+    });
+    defer zones.deinit(testing.allocator);
+
+    var buf: [max_reverse_len]u8 = undefined;
+    const v4 = reverseName(try address.NetAddress.parse("192.168.1.10"), &buf);
+    try testing.expectEqualStrings("168.192.in-addr.arpa", zones.match(v4).?.zone);
+
+    var buf6: [max_reverse_len]u8 = undefined;
+    const v6 = reverseName(try address.NetAddress.parse("fd00::1"), &buf6);
+    try testing.expectEqualStrings("0.0.d.f.ip6.arpa", zones.match(v6).?.zone);
+
+    // An address outside both declared reverse zones matches nothing, which is
+    // the `no_zone` outcome: no query is sent to anyone.
+    const outside = reverseName(try address.NetAddress.parse("10.0.0.1"), &buf);
+    try testing.expectEqual(@as(?*const forward_zones.Zone, null), zones.match(outside));
+}
+
+test "acceptHostname takes the boundary lengths and mixed case" {
+    try testing.expect(acceptHostname("a" ** 63));
+    // 253 bytes, the longest name accepted.
+    try testing.expect(acceptHostname("a" ** 63 ++ "." ++ "a" ** 63 ++ "." ++ "a" ** 63 ++ "." ++ "a" ** 61));
+    try testing.expect(acceptHostname("NAS-1.LAN"));
+    try testing.expect(!acceptHostname("x-"));
+    try testing.expect(!acceptHostname("a.-b"));
+    try testing.expect(!acceptHostname("a.b-.c"));
+}