| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris |
| |
| package net |
| |
| import ( |
| "net/netip" |
| "reflect" |
| "testing" |
| ) |
| |
| func TestSortByRFC6724(t *testing.T) { |
| tests := []struct { |
| in []IPAddr |
| srcs []netip.Addr |
| want []IPAddr |
| reverse bool // also test it starting backwards |
| }{ |
| // Examples from RFC 6724 section 10.2: |
| |
| // Prefer matching scope. |
| { |
| in: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("198.51.100.121")}, |
| }, |
| srcs: []netip.Addr{ |
| netip.MustParseAddr("2001:db8:1::2"), |
| netip.MustParseAddr("169.254.13.78"), |
| }, |
| want: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("198.51.100.121")}, |
| }, |
| reverse: true, |
| }, |
| |
| // Prefer matching scope. |
| { |
| in: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("198.51.100.121")}, |
| }, |
| srcs: []netip.Addr{ |
| netip.MustParseAddr("fe80::1"), |
| netip.MustParseAddr("198.51.100.117"), |
| }, |
| want: []IPAddr{ |
| {IP: ParseIP("198.51.100.121")}, |
| {IP: ParseIP("2001:db8:1::1")}, |
| }, |
| reverse: true, |
| }, |
| |
| // Prefer higher precedence. |
| { |
| in: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("10.1.2.3")}, |
| }, |
| srcs: []netip.Addr{ |
| netip.MustParseAddr("2001:db8:1::2"), |
| netip.MustParseAddr("10.1.2.4"), |
| }, |
| want: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("10.1.2.3")}, |
| }, |
| reverse: true, |
| }, |
| |
| // Prefer smaller scope. |
| { |
| in: []IPAddr{ |
| {IP: ParseIP("2001:db8:1::1")}, |
| {IP: ParseIP("fe80::1")}, |
| }, |
| srcs: []netip.Addr{ |
| netip.MustParseAddr("2001:db8:1::2"), |
| netip.MustParseAddr("fe80::2"), |
| }, |
| want: []IPAddr{ |
| {IP: ParseIP("fe80::1")}, |
| {IP: ParseIP("2001:db8:1::1")}, |
| }, |
| reverse: true, |
| }, |
| |
| // Issue 13283. Having a 10/8 source address does not |
| // mean we should prefer 23/8 destination addresses. |
| { |
| in: []IPAddr{ |
| {IP: ParseIP("54.83.193.112")}, |
| {IP: ParseIP("184.72.238.214")}, |
| {IP: ParseIP("23.23.172.185")}, |
| {IP: ParseIP("75.101.148.21")}, |
| {IP: ParseIP("23.23.134.56")}, |
| {IP: ParseIP("23.21.50.150")}, |
| }, |
| srcs: []netip.Addr{ |
| netip.MustParseAddr("10.2.3.4"), |
| netip.MustParseAddr("10.2.3.4"), |
| netip.MustParseAddr("10.2.3.4"), |
| netip.MustParseAddr("10.2.3.4"), |
| netip.MustParseAddr("10.2.3.4"), |
| netip.MustParseAddr("10.2.3.4"), |
| }, |
| want: []IPAddr{ |
| {IP: ParseIP("54.83.193.112")}, |
| {IP: ParseIP("184.72.238.214")}, |
| {IP: ParseIP("23.23.172.185")}, |
| {IP: ParseIP("75.101.148.21")}, |
| {IP: ParseIP("23.23.134.56")}, |
| {IP: ParseIP("23.21.50.150")}, |
| }, |
| reverse: false, |
| }, |
| } |
| for i, tt := range tests { |
| inCopy := make([]IPAddr, len(tt.in)) |
| copy(inCopy, tt.in) |
| srcCopy := make([]netip.Addr, len(tt.in)) |
| copy(srcCopy, tt.srcs) |
| sortByRFC6724withSrcs(inCopy, srcCopy) |
| if !reflect.DeepEqual(inCopy, tt.want) { |
| t.Errorf("test %d:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want) |
| } |
| if tt.reverse { |
| copy(inCopy, tt.in) |
| copy(srcCopy, tt.srcs) |
| for j := 0; j < len(inCopy)/2; j++ { |
| k := len(inCopy) - j - 1 |
| inCopy[j], inCopy[k] = inCopy[k], inCopy[j] |
| srcCopy[j], srcCopy[k] = srcCopy[k], srcCopy[j] |
| } |
| sortByRFC6724withSrcs(inCopy, srcCopy) |
| if !reflect.DeepEqual(inCopy, tt.want) { |
| t.Errorf("test %d, starting backwards:\nin = %s\ngot: %s\nwant: %s\n", i, tt.in, inCopy, tt.want) |
| } |
| } |
| |
| } |
| |
| } |
| |
| func TestRFC6724PolicyTableOrder(t *testing.T) { |
| for i := 0; i < len(rfc6724policyTable)-1; i++ { |
| if !(rfc6724policyTable[i].Prefix.Bits() >= rfc6724policyTable[i+1].Prefix.Bits()) { |
| t.Errorf("rfc6724policyTable item number %d sorted in wrong order = %d bits, next item = %d bits;", i, rfc6724policyTable[i].Prefix.Bits(), rfc6724policyTable[i+1].Prefix.Bits()) |
| } |
| } |
| } |
| |
| func TestRFC6724PolicyTableContent(t *testing.T) { |
| expectedRfc6724policyTable := policyTable{ |
| { |
| Prefix: netip.MustParsePrefix("::1/128"), |
| Precedence: 50, |
| Label: 0, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("::ffff:0:0/96"), |
| Precedence: 35, |
| Label: 4, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("::/96"), |
| Precedence: 1, |
| Label: 3, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("2001::/32"), |
| Precedence: 5, |
| Label: 5, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("2002::/16"), |
| Precedence: 30, |
| Label: 2, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("3ffe::/16"), |
| Precedence: 1, |
| Label: 12, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("fec0::/10"), |
| Precedence: 1, |
| Label: 11, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("fc00::/7"), |
| Precedence: 3, |
| Label: 13, |
| }, |
| { |
| Prefix: netip.MustParsePrefix("::/0"), |
| Precedence: 40, |
| Label: 1, |
| }, |
| } |
| if !reflect.DeepEqual(rfc6724policyTable, expectedRfc6724policyTable) { |
| t.Errorf("rfc6724policyTable has wrong contend = %v; want %v", rfc6724policyTable, expectedRfc6724policyTable) |
| } |
| } |
| |
| func TestRFC6724PolicyTableClassify(t *testing.T) { |
| tests := []struct { |
| ip netip.Addr |
| want policyTableEntry |
| }{ |
| { |
| ip: netip.MustParseAddr("127.0.0.1"), |
| want: policyTableEntry{ |
| Prefix: netip.MustParsePrefix("::ffff:0:0/96"), |
| Precedence: 35, |
| Label: 4, |
| }, |
| }, |
| { |
| ip: netip.MustParseAddr("2601:645:8002:a500:986f:1db8:c836:bd65"), |
| want: policyTableEntry{ |
| Prefix: netip.MustParsePrefix("::/0"), |
| Precedence: 40, |
| Label: 1, |
| }, |
| }, |
| { |
| ip: netip.MustParseAddr("::1"), |
| want: policyTableEntry{ |
| Prefix: netip.MustParsePrefix("::1/128"), |
| Precedence: 50, |
| Label: 0, |
| }, |
| }, |
| { |
| ip: netip.MustParseAddr("2002::ab12"), |
| want: policyTableEntry{ |
| Prefix: netip.MustParsePrefix("2002::/16"), |
| Precedence: 30, |
| Label: 2, |
| }, |
| }, |
| } |
| for i, tt := range tests { |
| got := rfc6724policyTable.Classify(tt.ip) |
| if !reflect.DeepEqual(got, tt.want) { |
| t.Errorf("%d. Classify(%s) = %v; want %v", i, tt.ip, got, tt.want) |
| } |
| } |
| } |
| |
| func TestRFC6724ClassifyScope(t *testing.T) { |
| tests := []struct { |
| ip netip.Addr |
| want scope |
| }{ |
| {netip.MustParseAddr("127.0.0.1"), scopeLinkLocal}, // rfc6724#section-3.2 |
| {netip.MustParseAddr("::1"), scopeLinkLocal}, // rfc4007#section-4 |
| {netip.MustParseAddr("169.254.1.2"), scopeLinkLocal}, // rfc6724#section-3.2 |
| {netip.MustParseAddr("fec0::1"), scopeSiteLocal}, |
| {netip.MustParseAddr("8.8.8.8"), scopeGlobal}, |
| |
| {netip.MustParseAddr("ff02::"), scopeLinkLocal}, // IPv6 multicast |
| {netip.MustParseAddr("ff05::"), scopeSiteLocal}, // IPv6 multicast |
| {netip.MustParseAddr("ff04::"), scopeAdminLocal}, // IPv6 multicast |
| {netip.MustParseAddr("ff0e::"), scopeGlobal}, // IPv6 multicast |
| |
| {netip.AddrFrom16([16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xe0, 0, 0, 0}), scopeGlobal}, // IPv4 link-local multicast as 16 bytes |
| {netip.AddrFrom16([16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xe0, 2, 2, 2}), scopeGlobal}, // IPv4 global multicast as 16 bytes |
| {netip.AddrFrom4([4]byte{0xe0, 0, 0, 0}), scopeGlobal}, // IPv4 link-local multicast as 4 bytes |
| {netip.AddrFrom4([4]byte{0xe0, 2, 2, 2}), scopeGlobal}, // IPv4 global multicast as 4 bytes |
| } |
| for i, tt := range tests { |
| got := classifyScope(tt.ip) |
| if got != tt.want { |
| t.Errorf("%d. classifyScope(%s) = %x; want %x", i, tt.ip, got, tt.want) |
| } |
| } |
| } |
| |
| func TestRFC6724CommonPrefixLength(t *testing.T) { |
| tests := []struct { |
| a netip.Addr |
| b IP |
| want int |
| }{ |
| {netip.MustParseAddr("fe80::1"), ParseIP("fe80::2"), 64}, |
| {netip.MustParseAddr("fe81::1"), ParseIP("fe80::2"), 15}, |
| {netip.MustParseAddr("127.0.0.1"), ParseIP("fe80::1"), 0}, // diff size |
| {netip.AddrFrom4([4]byte{1, 2, 3, 4}), IP{1, 2, 3, 4}, 32}, |
| {netip.AddrFrom4([4]byte{1, 2, 255, 255}), IP{1, 2, 0, 0}, 16}, |
| {netip.AddrFrom4([4]byte{1, 2, 127, 255}), IP{1, 2, 0, 0}, 17}, |
| {netip.AddrFrom4([4]byte{1, 2, 63, 255}), IP{1, 2, 0, 0}, 18}, |
| {netip.AddrFrom4([4]byte{1, 2, 31, 255}), IP{1, 2, 0, 0}, 19}, |
| {netip.AddrFrom4([4]byte{1, 2, 15, 255}), IP{1, 2, 0, 0}, 20}, |
| {netip.AddrFrom4([4]byte{1, 2, 7, 255}), IP{1, 2, 0, 0}, 21}, |
| {netip.AddrFrom4([4]byte{1, 2, 3, 255}), IP{1, 2, 0, 0}, 22}, |
| {netip.AddrFrom4([4]byte{1, 2, 1, 255}), IP{1, 2, 0, 0}, 23}, |
| {netip.AddrFrom4([4]byte{1, 2, 0, 255}), IP{1, 2, 0, 0}, 24}, |
| } |
| for i, tt := range tests { |
| got := commonPrefixLen(tt.a, tt.b) |
| if got != tt.want { |
| t.Errorf("%d. commonPrefixLen(%s, %s) = %d; want %d", i, tt.a, tt.b, got, tt.want) |
| } |
| } |
| |
| } |
