proposal: net/netip: add `UnmappedEquals(netip.AddrPort)` to `netip.AddrPort`

[database64128]

In configuration and other places, IPv4 addresses are usually specified unmapped, like 1.1.1.1:53. When dealing with ReadFromUDPAddrPort and ReadMsgUDPAddrPort, the returned netip.AddrPort is likely to be an IPv4-mapped IPv6 address, like [::ffff:1.1.1.1]:53, depending on how the UDP socket was opened.

To check whether these 2 addresses point to the same endpoint, we would have to do something like:

// AddrPortMappedEqual returns whether the two addresses point to the same endpoint.
// An IPv4 address and an IPv4-mapped IPv6 address pointing to the same endpoint are considered equal.
// For example, 1.1.1.1:53 and [::ffff:1.1.1.1]:53 are considered equal.
func AddrPortMappedEqual(l, r netip.AddrPort) bool {
    if l == r {
        return true
    }
    return l.Port() == r.Port() && l.Addr().Unmap() == r.Addr().Unmap()
}

It'd be nice if we have a method on netip.AddrPort to directly compare the unexported addr field in netip.Addr. I propose we add something like:

func (p AddrPort) UnmappedEquals(p1 netip.AddrPort) bool {
    return p.port == p1.port && p.ip.addr == p1.ip.addr
}

The method can also be called MappedEquals if #54365 is accepted.

/cc @bradfitz

[bradfitz]

I don't think we want to add API for this. We're trying to fix the real problem (ReadMsgUDPAddrPort etc returning bad netip.Addr/AddrPort values) instead in #54234

[database64128]

I wouldn't call this "the real problem" or "bad values". It is natural for ReadMsgUDPAddrPort calls on IPv6 UDP sockets to return IPv4-mapped IPv6 addresses, because that's how the underlying socket works. A method like UnmappedEquals allows us to conveniently compare the returned address without changing the address family.

[database64128]

The following benchmark uses AddrPortMappedEqualUnsafe to simulate the proposed UnmappedEquals.

// AddrPortMappedEqual returns whether the two addresses point to the same endpoint.
// An IPv4 address and an IPv4-mapped IPv6 address pointing to the same endpoint are considered equal.
// For example, 1.1.1.1:53 and [::ffff:1.1.1.1]:53 are considered equal.
func AddrPortMappedEqual(l, r netip.AddrPort) bool {
    if l == r {
        return true
    }
    return l.Port() == r.Port() && l.Addr().Unmap() == r.Addr().Unmap()
}

type addrPortHeader struct {
    ip   [16]byte
    z    unsafe.Pointer
    port uint16
}

func AddrPortMappedEqualUnsafe(l, r netip.AddrPort) bool {
    lp := (*addrPortHeader)(unsafe.Pointer(&l))
    rp := (*addrPortHeader)(unsafe.Pointer(&r))
    return lp.ip == rp.ip && lp.port == rp.port
}

var (
    addrPort4    = netip.AddrPortFrom(netip.AddrFrom4([4]byte{127, 0, 0, 1}), 1080)
    addrPort4in6 = netip.AddrPortFrom(netip.AddrFrom16([16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 127, 0, 0, 1}), 1080)
)

func BenchmarkAddrPortMappedEqual(b *testing.B) {
    b.Run("Equal", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            AddrPortMappedEqual(addrPort4, addrPort4)
        }
    })

    b.Run("NotEqual", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            AddrPortMappedEqual(addrPort4, addrPort4in6)
        }
    })
}

func BenchmarkAddrPortMappedEqualUnsafe(b *testing.B) {
    b.Run("Equal", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            AddrPortMappedEqualUnsafe(addrPort4, addrPort4)
        }
    })

    b.Run("NotEqual", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            AddrPortMappedEqualUnsafe(addrPort4, addrPort4in6)
        }
    })
}

BenchmarkAddrPortMappedEqual/Equal-4    490546808            2.446 ns/op           0 B/op          0 allocs/op
BenchmarkAddrPortMappedEqual/NotEqual-4             250462476            4.730 ns/op           0 B/op          0 allocs/op
BenchmarkAddrPortMappedEqualUnsafe/Equal-4          1000000000           0.4085 ns/op          0 B/op          0 allocs/op
BenchmarkAddrPortMappedEqualUnsafe/NotEqual-4       1000000000           0.3842 ns/op          0 B/op          0 allocs/op