DnsResolve

        // aligned with one literal.
        if (ZstrLen(hostname) >= 256) {
            LOG_ERROR("DnsResolve: hostname \"{}\" exceeds 255 bytes", hostname);
            return false;
        }

            // 2. Nameserver query path.
            if (VecLen(&self->nameservers) == 0) {
                LOG_ERROR("DnsResolve: no nameservers configured (read /etc/resolv.conf at init)");
                break;
            }

    
            if (!found) {
                LOG_ERROR("DnsResolve: no A/AAAA records found for \"{}\"", hostname);
            }
        }

        }
        if (colon_at >= spec_len) {
            LOG_ERROR("DnsResolve: spec \"{}\" has no \":port\"", spec);
            return false;
        }

        }
        if (colon_at >= 256) {
            LOG_ERROR("DnsResolve: host portion of \"{}\" exceeds 255 bytes", spec);
            return false;
        }

            char c = spec[i];
            if (c < '0' || c > '9') {
                LOG_ERROR("DnsResolve: non-numeric port in \"{}\"", spec);
                return false;
            }

            u32 next = (u32)port * 10u + (u32)(c - '0');
            if (next > 0xFFFFu) {
                LOG_ERROR("DnsResolve: port in \"{}\" out of range", spec);
                return false;
            }

        // A bare "host:" with no digits after the colon is malformed.
        if (colon_at + 1 == spec_len) {
            LOG_ERROR("DnsResolve: empty port in \"{}\"", spec);
            return false;
        }

    
            DnsAddrs addrs = VecInitT(addrs, alloc);
            if (!DnsResolve(&r, hostname, 0, SOCKET_KIND_TCP, &addrs)) {
                DnsResolverDeinit(&r);
                return 1;

    
            SocketAddr listen_addr;
            if (!DnsResolve(&resolver, listen_spec, SOCKET_KIND_TCP, &listen_addr)) {
                LOG_ERROR("invalid --listen address: {}", listen_spec);
                DnsResolverDeinit(&resolver);

    
            SocketAddr upstream_addr;
            if (!DnsResolve(&resolver, upstream_spec, SOCKET_KIND_TCP, &upstream_addr)) {
                LOG_ERROR("invalid --upstream address: {}", upstream_spec);
                DnsResolverDeinit(&resolver);

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost", 8080, SOCKET_KIND_TCP, &out);
    
        bool found_v4 = false;

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "LocalHost", 0, SOCKET_KIND_TCP, &out);
    
        VecDeinit(&out);

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost.", 0, SOCKET_KIND_TCP, &out);
    
        VecDeinit(&out);

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);
    
        bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET;

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "[::1]:443", SOCKET_KIND_TCP, &out);
    
        bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET6;

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost:53", SOCKET_KIND_TCP, &out);
    
        bool ok = got && VecLen(&out) > 0;

    
        SocketAddr one;
        bool       got = DnsResolve(&r, "127.0.0.1:80", SOCKET_KIND_TCP, &one);
    
        bool ok = got && one.family == SOCKET_FAMILY_INET;

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost", SOCKET_KIND_TCP, &out);
    
        bool ok = !got && VecLen(&out) == 0;

    
        DnsAddrs out = VecInitT(out, a);
        bool     got = DnsResolve(&r, "localhost:abc", SOCKET_KIND_TCP, &out);
    
        bool ok = !got;