...
Run Format

Source file src/net/interface_test.go

Documentation: net

  // 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)
  		}
  		switch runtime.GOOS {
  		case "solaris":
  			if ifxi.Index != ifi.Index {
  				t.Errorf("got %v; want %v", ifxi, ifi)
  			}
  		default:
  			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)
  		}
  	}
  }
  

View as plain text