| // Copyright 2011 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. |
| |
| package net |
| |
| import ( |
| "fmt" |
| "reflect" |
| "runtime" |
| "testing" |
| ) |
| |
| // loopbackInterface returns an available logical network interface |
| // for loopback tests. It returns nil if no suitable interface is |
| // found. |
| func loopbackInterface() *Interface { |
| ift, err := Interfaces() |
| if err != nil { |
| return nil |
| } |
| for _, ifi := range ift { |
| if ifi.Flags&FlagLoopback != 0 && ifi.Flags&FlagUp != 0 { |
| return &ifi |
| } |
| } |
| return nil |
| } |
| |
| // ipv6LinkLocalUnicastAddr returns an IPv6 link-local unicast address |
| // on the given network interface for tests. It returns "" if no |
| // suitable address is found. |
| func ipv6LinkLocalUnicastAddr(ifi *Interface) string { |
| if ifi == nil { |
| return "" |
| } |
| ifat, err := ifi.Addrs() |
| if err != nil { |
| return "" |
| } |
| for _, ifa := range ifat { |
| if ifa, ok := ifa.(*IPNet); ok { |
| if ifa.IP.To4() == nil && ifa.IP.IsLinkLocalUnicast() { |
| return ifa.IP.String() |
| } |
| } |
| } |
| return "" |
| } |
| |
| func TestInterfaces(t *testing.T) { |
| ift, err := Interfaces() |
| if err != nil { |
| t.Fatal(err) |
| } |
| for _, ifi := range ift { |
| ifxi, err := InterfaceByIndex(ifi.Index) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !reflect.DeepEqual(ifxi, &ifi) { |
| t.Errorf("got %v; want %v", ifxi, ifi) |
| } |
| ifxn, err := InterfaceByName(ifi.Name) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !reflect.DeepEqual(ifxn, &ifi) { |
| t.Errorf("got %v; want %v", ifxn, ifi) |
| } |
| t.Logf("%s: flags=%v index=%d mtu=%d hwaddr=%v", ifi.Name, ifi.Flags, ifi.Index, ifi.MTU, ifi.HardwareAddr) |
| } |
| } |
| |
| func TestInterfaceAddrs(t *testing.T) { |
| ift, err := Interfaces() |
| if err != nil { |
| t.Fatal(err) |
| } |
| ifStats := interfaceStats(ift) |
| ifat, err := InterfaceAddrs() |
| if err != nil { |
| t.Fatal(err) |
| } |
| uniStats, err := validateInterfaceUnicastAddrs(ifat) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if err := checkUnicastStats(ifStats, uniStats); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestInterfaceUnicastAddrs(t *testing.T) { |
| ift, err := Interfaces() |
| if err != nil { |
| t.Fatal(err) |
| } |
| ifStats := interfaceStats(ift) |
| if err != nil { |
| t.Fatal(err) |
| } |
| var uniStats routeStats |
| for _, ifi := range ift { |
| ifat, err := ifi.Addrs() |
| if err != nil { |
| t.Fatal(ifi, err) |
| } |
| stats, err := validateInterfaceUnicastAddrs(ifat) |
| if err != nil { |
| t.Fatal(ifi, err) |
| } |
| uniStats.ipv4 += stats.ipv4 |
| uniStats.ipv6 += stats.ipv6 |
| } |
| if err := checkUnicastStats(ifStats, &uniStats); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestInterfaceMulticastAddrs(t *testing.T) { |
| ift, err := Interfaces() |
| if err != nil { |
| t.Fatal(err) |
| } |
| ifStats := interfaceStats(ift) |
| ifat, err := InterfaceAddrs() |
| if err != nil { |
| t.Fatal(err) |
| } |
| uniStats, err := validateInterfaceUnicastAddrs(ifat) |
| if err != nil { |
| t.Fatal(err) |
| } |
| var multiStats routeStats |
| for _, ifi := range ift { |
| ifmat, err := ifi.MulticastAddrs() |
| if err != nil { |
| t.Fatal(ifi, err) |
| } |
| stats, err := validateInterfaceMulticastAddrs(ifmat) |
| if err != nil { |
| t.Fatal(ifi, err) |
| } |
| multiStats.ipv4 += stats.ipv4 |
| multiStats.ipv6 += stats.ipv6 |
| } |
| if err := checkMulticastStats(ifStats, uniStats, &multiStats); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| type ifStats struct { |
| loop int // # of active loopback interfaces |
| other int // # of active other interfaces |
| } |
| |
| func interfaceStats(ift []Interface) *ifStats { |
| var stats ifStats |
| for _, ifi := range ift { |
| if ifi.Flags&FlagUp != 0 { |
| if ifi.Flags&FlagLoopback != 0 { |
| stats.loop++ |
| } else { |
| stats.other++ |
| } |
| } |
| } |
| return &stats |
| } |
| |
| type routeStats struct { |
| ipv4, ipv6 int // # of active connected unicast, anycast or multicast routes |
| } |
| |
| func validateInterfaceUnicastAddrs(ifat []Addr) (*routeStats, error) { |
| // Note: BSD variants allow assigning any IPv4/IPv6 address |
| // prefix to IP interface. For example, |
| // - 0.0.0.0/0 through 255.255.255.255/32 |
| // - ::/0 through ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128 |
| // In other words, there is no tightly-coupled combination of |
| // interface address prefixes and connected routes. |
| stats := new(routeStats) |
| for _, ifa := range ifat { |
| switch ifa := ifa.(type) { |
| case *IPNet: |
| if ifa == nil || ifa.IP == nil || ifa.IP.IsMulticast() || ifa.Mask == nil { |
| return nil, fmt.Errorf("unexpected value: %#v", ifa) |
| } |
| if len(ifa.IP) != IPv6len { |
| return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa) |
| } |
| prefixLen, maxPrefixLen := ifa.Mask.Size() |
| if ifa.IP.To4() != nil { |
| if 0 >= prefixLen || prefixLen > 8*IPv4len || maxPrefixLen != 8*IPv4len { |
| return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa) |
| } |
| if ifa.IP.IsLoopback() && (prefixLen != 8 && prefixLen != 8*IPv4len) { // see RFC 1122 |
| return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa) |
| } |
| stats.ipv4++ |
| } |
| if ifa.IP.To16() != nil && ifa.IP.To4() == nil { |
| if 0 >= prefixLen || prefixLen > 8*IPv6len || maxPrefixLen != 8*IPv6len { |
| return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa) |
| } |
| if ifa.IP.IsLoopback() && prefixLen != 8*IPv6len { // see RFC 4291 |
| return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa) |
| } |
| stats.ipv6++ |
| } |
| case *IPAddr: |
| if ifa == nil || ifa.IP == nil || ifa.IP.IsMulticast() { |
| return nil, fmt.Errorf("unexpected value: %#v", ifa) |
| } |
| if len(ifa.IP) != IPv6len { |
| return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa) |
| } |
| if ifa.IP.To4() != nil { |
| stats.ipv4++ |
| } |
| if ifa.IP.To16() != nil && ifa.IP.To4() == nil { |
| stats.ipv6++ |
| } |
| default: |
| return nil, fmt.Errorf("unexpected type: %T", ifa) |
| } |
| } |
| return stats, nil |
| } |
| |
| func validateInterfaceMulticastAddrs(ifat []Addr) (*routeStats, error) { |
| stats := new(routeStats) |
| for _, ifa := range ifat { |
| switch ifa := ifa.(type) { |
| case *IPAddr: |
| if ifa == nil || ifa.IP == nil || ifa.IP.IsUnspecified() || !ifa.IP.IsMulticast() { |
| return nil, fmt.Errorf("unexpected value: %#v", ifa) |
| } |
| if len(ifa.IP) != IPv6len { |
| return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa) |
| } |
| if ifa.IP.To4() != nil { |
| stats.ipv4++ |
| } |
| if ifa.IP.To16() != nil && ifa.IP.To4() == nil { |
| stats.ipv6++ |
| } |
| default: |
| return nil, fmt.Errorf("unexpected type: %T", ifa) |
| } |
| } |
| return stats, nil |
| } |
| |
| func checkUnicastStats(ifStats *ifStats, uniStats *routeStats) error { |
| // Test the existence of connected unicast routes for IPv4. |
| if supportsIPv4 && ifStats.loop+ifStats.other > 0 && uniStats.ipv4 == 0 { |
| return fmt.Errorf("num IPv4 unicast routes = 0; want >0; summary: %+v, %+v", ifStats, uniStats) |
| } |
| // Test the existence of connected unicast routes for IPv6. |
| // We can assume the existence of ::1/128 when at least one |
| // loopback interface is installed. |
| if supportsIPv6 && ifStats.loop > 0 && uniStats.ipv6 == 0 { |
| return fmt.Errorf("num IPv6 unicast routes = 0; want >0; summary: %+v, %+v", ifStats, uniStats) |
| } |
| return nil |
| } |
| |
| func checkMulticastStats(ifStats *ifStats, uniStats, multiStats *routeStats) error { |
| switch runtime.GOOS { |
| case "dragonfly", "nacl", "netbsd", "openbsd", "plan9", "solaris": |
| default: |
| // Test the existence of connected multicast route |
| // clones for IPv4. Unlike IPv6, IPv4 multicast |
| // capability is not a mandatory feature, and so IPv4 |
| // multicast validation is ignored and we only check |
| // IPv6 below. |
| // |
| // Test the existence of connected multicast route |
| // clones for IPv6. Some platform never uses loopback |
| // interface as the nexthop for multicast routing. |
| // We can assume the existence of connected multicast |
| // route clones when at least two connected unicast |
| // routes, ::1/128 and other, are installed. |
| if supportsIPv6 && ifStats.loop > 0 && uniStats.ipv6 > 1 && multiStats.ipv6 == 0 { |
| return fmt.Errorf("num IPv6 multicast route clones = 0; want >0; summary: %+v, %+v, %+v", ifStats, uniStats, multiStats) |
| } |
| } |
| return nil |
| } |
| |
| func BenchmarkInterfaces(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| for i := 0; i < b.N; i++ { |
| if _, err := Interfaces(); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkInterfaceByIndex(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| ifi := loopbackInterface() |
| if ifi == nil { |
| b.Skip("loopback interface not found") |
| } |
| for i := 0; i < b.N; i++ { |
| if _, err := InterfaceByIndex(ifi.Index); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkInterfaceByName(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| ifi := loopbackInterface() |
| if ifi == nil { |
| b.Skip("loopback interface not found") |
| } |
| for i := 0; i < b.N; i++ { |
| if _, err := InterfaceByName(ifi.Name); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkInterfaceAddrs(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| for i := 0; i < b.N; i++ { |
| if _, err := InterfaceAddrs(); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkInterfacesAndAddrs(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| ifi := loopbackInterface() |
| if ifi == nil { |
| b.Skip("loopback interface not found") |
| } |
| for i := 0; i < b.N; i++ { |
| if _, err := ifi.Addrs(); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |
| |
| func BenchmarkInterfacesAndMulticastAddrs(b *testing.B) { |
| testHookUninstaller.Do(uninstallTestHooks) |
| |
| ifi := loopbackInterface() |
| if ifi == nil { |
| b.Skip("loopback interface not found") |
| } |
| for i := 0; i < b.N; i++ { |
| if _, err := ifi.MulticastAddrs(); err != nil { |
| b.Fatal(err) |
| } |
| } |
| } |