Source file src/net/interface_test.go

Documentation: net

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build !js
     6  // +build !js
     7  
     8  package net
     9  
    10  import (
    11  	"fmt"
    12  	"reflect"
    13  	"runtime"
    14  	"testing"
    15  )
    16  
    17  // loopbackInterface returns an available logical network interface
    18  // for loopback tests. It returns nil if no suitable interface is
    19  // found.
    20  func loopbackInterface() *Interface {
    21  	ift, err := Interfaces()
    22  	if err != nil {
    23  		return nil
    24  	}
    25  	for _, ifi := range ift {
    26  		if ifi.Flags&FlagLoopback != 0 && ifi.Flags&FlagUp != 0 {
    27  			return &ifi
    28  		}
    29  	}
    30  	return nil
    31  }
    32  
    33  // ipv6LinkLocalUnicastAddr returns an IPv6 link-local unicast address
    34  // on the given network interface for tests. It returns "" if no
    35  // suitable address is found.
    36  func ipv6LinkLocalUnicastAddr(ifi *Interface) string {
    37  	if ifi == nil {
    38  		return ""
    39  	}
    40  	ifat, err := ifi.Addrs()
    41  	if err != nil {
    42  		return ""
    43  	}
    44  	for _, ifa := range ifat {
    45  		if ifa, ok := ifa.(*IPNet); ok {
    46  			if ifa.IP.To4() == nil && ifa.IP.IsLinkLocalUnicast() {
    47  				return ifa.IP.String()
    48  			}
    49  		}
    50  	}
    51  	return ""
    52  }
    53  
    54  func TestInterfaces(t *testing.T) {
    55  	ift, err := Interfaces()
    56  	if err != nil {
    57  		t.Fatal(err)
    58  	}
    59  	for _, ifi := range ift {
    60  		ifxi, err := InterfaceByIndex(ifi.Index)
    61  		if err != nil {
    62  			t.Fatal(err)
    63  		}
    64  		switch runtime.GOOS {
    65  		case "solaris", "illumos":
    66  			if ifxi.Index != ifi.Index {
    67  				t.Errorf("got %v; want %v", ifxi, ifi)
    68  			}
    69  		default:
    70  			if !reflect.DeepEqual(ifxi, &ifi) {
    71  				t.Errorf("got %v; want %v", ifxi, ifi)
    72  			}
    73  		}
    74  		ifxn, err := InterfaceByName(ifi.Name)
    75  		if err != nil {
    76  			t.Fatal(err)
    77  		}
    78  		if !reflect.DeepEqual(ifxn, &ifi) {
    79  			t.Errorf("got %v; want %v", ifxn, ifi)
    80  		}
    81  		t.Logf("%s: flags=%v index=%d mtu=%d hwaddr=%v", ifi.Name, ifi.Flags, ifi.Index, ifi.MTU, ifi.HardwareAddr)
    82  	}
    83  }
    84  
    85  func TestInterfaceAddrs(t *testing.T) {
    86  	ift, err := Interfaces()
    87  	if err != nil {
    88  		t.Fatal(err)
    89  	}
    90  	ifStats := interfaceStats(ift)
    91  	ifat, err := InterfaceAddrs()
    92  	if err != nil {
    93  		t.Fatal(err)
    94  	}
    95  	uniStats, err := validateInterfaceUnicastAddrs(ifat)
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  	if err := checkUnicastStats(ifStats, uniStats); err != nil {
   100  		t.Fatal(err)
   101  	}
   102  }
   103  
   104  func TestInterfaceUnicastAddrs(t *testing.T) {
   105  	ift, err := Interfaces()
   106  	if err != nil {
   107  		t.Fatal(err)
   108  	}
   109  	ifStats := interfaceStats(ift)
   110  	if err != nil {
   111  		t.Fatal(err)
   112  	}
   113  	var uniStats routeStats
   114  	for _, ifi := range ift {
   115  		ifat, err := ifi.Addrs()
   116  		if err != nil {
   117  			t.Fatal(ifi, err)
   118  		}
   119  		stats, err := validateInterfaceUnicastAddrs(ifat)
   120  		if err != nil {
   121  			t.Fatal(ifi, err)
   122  		}
   123  		uniStats.ipv4 += stats.ipv4
   124  		uniStats.ipv6 += stats.ipv6
   125  	}
   126  	if err := checkUnicastStats(ifStats, &uniStats); err != nil {
   127  		t.Fatal(err)
   128  	}
   129  }
   130  
   131  func TestInterfaceMulticastAddrs(t *testing.T) {
   132  	ift, err := Interfaces()
   133  	if err != nil {
   134  		t.Fatal(err)
   135  	}
   136  	ifStats := interfaceStats(ift)
   137  	ifat, err := InterfaceAddrs()
   138  	if err != nil {
   139  		t.Fatal(err)
   140  	}
   141  	uniStats, err := validateInterfaceUnicastAddrs(ifat)
   142  	if err != nil {
   143  		t.Fatal(err)
   144  	}
   145  	var multiStats routeStats
   146  	for _, ifi := range ift {
   147  		ifmat, err := ifi.MulticastAddrs()
   148  		if err != nil {
   149  			t.Fatal(ifi, err)
   150  		}
   151  		stats, err := validateInterfaceMulticastAddrs(ifmat)
   152  		if err != nil {
   153  			t.Fatal(ifi, err)
   154  		}
   155  		multiStats.ipv4 += stats.ipv4
   156  		multiStats.ipv6 += stats.ipv6
   157  	}
   158  	if err := checkMulticastStats(ifStats, uniStats, &multiStats); err != nil {
   159  		t.Fatal(err)
   160  	}
   161  }
   162  
   163  type ifStats struct {
   164  	loop  int // # of active loopback interfaces
   165  	other int // # of active other interfaces
   166  }
   167  
   168  func interfaceStats(ift []Interface) *ifStats {
   169  	var stats ifStats
   170  	for _, ifi := range ift {
   171  		if ifi.Flags&FlagUp != 0 {
   172  			if ifi.Flags&FlagLoopback != 0 {
   173  				stats.loop++
   174  			} else {
   175  				stats.other++
   176  			}
   177  		}
   178  	}
   179  	return &stats
   180  }
   181  
   182  type routeStats struct {
   183  	ipv4, ipv6 int // # of active connected unicast, anycast or multicast routes
   184  }
   185  
   186  func validateInterfaceUnicastAddrs(ifat []Addr) (*routeStats, error) {
   187  	// Note: BSD variants allow assigning any IPv4/IPv6 address
   188  	// prefix to IP interface. For example,
   189  	//   - 0.0.0.0/0 through 255.255.255.255/32
   190  	//   - ::/0 through ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128
   191  	// In other words, there is no tightly-coupled combination of
   192  	// interface address prefixes and connected routes.
   193  	stats := new(routeStats)
   194  	for _, ifa := range ifat {
   195  		switch ifa := ifa.(type) {
   196  		case *IPNet:
   197  			if ifa == nil || ifa.IP == nil || ifa.IP.IsMulticast() || ifa.Mask == nil {
   198  				return nil, fmt.Errorf("unexpected value: %#v", ifa)
   199  			}
   200  			if len(ifa.IP) != IPv6len {
   201  				return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa)
   202  			}
   203  			prefixLen, maxPrefixLen := ifa.Mask.Size()
   204  			if ifa.IP.To4() != nil {
   205  				if 0 >= prefixLen || prefixLen > 8*IPv4len || maxPrefixLen != 8*IPv4len {
   206  					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
   207  				}
   208  				if ifa.IP.IsLoopback() && prefixLen < 8 { // see RFC 1122
   209  					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
   210  				}
   211  				stats.ipv4++
   212  			}
   213  			if ifa.IP.To16() != nil && ifa.IP.To4() == nil {
   214  				if 0 >= prefixLen || prefixLen > 8*IPv6len || maxPrefixLen != 8*IPv6len {
   215  					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
   216  				}
   217  				if ifa.IP.IsLoopback() && prefixLen != 8*IPv6len { // see RFC 4291
   218  					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
   219  				}
   220  				stats.ipv6++
   221  			}
   222  		case *IPAddr:
   223  			if ifa == nil || ifa.IP == nil || ifa.IP.IsMulticast() {
   224  				return nil, fmt.Errorf("unexpected value: %#v", ifa)
   225  			}
   226  			if len(ifa.IP) != IPv6len {
   227  				return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa)
   228  			}
   229  			if ifa.IP.To4() != nil {
   230  				stats.ipv4++
   231  			}
   232  			if ifa.IP.To16() != nil && ifa.IP.To4() == nil {
   233  				stats.ipv6++
   234  			}
   235  		default:
   236  			return nil, fmt.Errorf("unexpected type: %T", ifa)
   237  		}
   238  	}
   239  	return stats, nil
   240  }
   241  
   242  func validateInterfaceMulticastAddrs(ifat []Addr) (*routeStats, error) {
   243  	stats := new(routeStats)
   244  	for _, ifa := range ifat {
   245  		switch ifa := ifa.(type) {
   246  		case *IPAddr:
   247  			if ifa == nil || ifa.IP == nil || ifa.IP.IsUnspecified() || !ifa.IP.IsMulticast() {
   248  				return nil, fmt.Errorf("unexpected value: %#v", ifa)
   249  			}
   250  			if len(ifa.IP) != IPv6len {
   251  				return nil, fmt.Errorf("should be internal representation either IPv6 or IPv4-mapped IPv6 address: %#v", ifa)
   252  			}
   253  			if ifa.IP.To4() != nil {
   254  				stats.ipv4++
   255  			}
   256  			if ifa.IP.To16() != nil && ifa.IP.To4() == nil {
   257  				stats.ipv6++
   258  			}
   259  		default:
   260  			return nil, fmt.Errorf("unexpected type: %T", ifa)
   261  		}
   262  	}
   263  	return stats, nil
   264  }
   265  
   266  func checkUnicastStats(ifStats *ifStats, uniStats *routeStats) error {
   267  	// Test the existence of connected unicast routes for IPv4.
   268  	if supportsIPv4() && ifStats.loop+ifStats.other > 0 && uniStats.ipv4 == 0 {
   269  		return fmt.Errorf("num IPv4 unicast routes = 0; want >0; summary: %+v, %+v", ifStats, uniStats)
   270  	}
   271  	// Test the existence of connected unicast routes for IPv6.
   272  	// We can assume the existence of ::1/128 when at least one
   273  	// loopback interface is installed.
   274  	if supportsIPv6() && ifStats.loop > 0 && uniStats.ipv6 == 0 {
   275  		return fmt.Errorf("num IPv6 unicast routes = 0; want >0; summary: %+v, %+v", ifStats, uniStats)
   276  	}
   277  	return nil
   278  }
   279  
   280  func checkMulticastStats(ifStats *ifStats, uniStats, multiStats *routeStats) error {
   281  	switch runtime.GOOS {
   282  	case "aix", "dragonfly", "netbsd", "openbsd", "plan9", "solaris", "illumos":
   283  	default:
   284  		// Test the existence of connected multicast route
   285  		// clones for IPv4. Unlike IPv6, IPv4 multicast
   286  		// capability is not a mandatory feature, and so IPv4
   287  		// multicast validation is ignored and we only check
   288  		// IPv6 below.
   289  		//
   290  		// Test the existence of connected multicast route
   291  		// clones for IPv6. Some platform never uses loopback
   292  		// interface as the nexthop for multicast routing.
   293  		// We can assume the existence of connected multicast
   294  		// route clones when at least two connected unicast
   295  		// routes, ::1/128 and other, are installed.
   296  		if supportsIPv6() && ifStats.loop > 0 && uniStats.ipv6 > 1 && multiStats.ipv6 == 0 {
   297  			return fmt.Errorf("num IPv6 multicast route clones = 0; want >0; summary: %+v, %+v, %+v", ifStats, uniStats, multiStats)
   298  		}
   299  	}
   300  	return nil
   301  }
   302  
   303  func BenchmarkInterfaces(b *testing.B) {
   304  	testHookUninstaller.Do(uninstallTestHooks)
   305  
   306  	for i := 0; i < b.N; i++ {
   307  		if _, err := Interfaces(); err != nil {
   308  			b.Fatal(err)
   309  		}
   310  	}
   311  }
   312  
   313  func BenchmarkInterfaceByIndex(b *testing.B) {
   314  	testHookUninstaller.Do(uninstallTestHooks)
   315  
   316  	ifi := loopbackInterface()
   317  	if ifi == nil {
   318  		b.Skip("loopback interface not found")
   319  	}
   320  	for i := 0; i < b.N; i++ {
   321  		if _, err := InterfaceByIndex(ifi.Index); err != nil {
   322  			b.Fatal(err)
   323  		}
   324  	}
   325  }
   326  
   327  func BenchmarkInterfaceByName(b *testing.B) {
   328  	testHookUninstaller.Do(uninstallTestHooks)
   329  
   330  	ifi := loopbackInterface()
   331  	if ifi == nil {
   332  		b.Skip("loopback interface not found")
   333  	}
   334  	for i := 0; i < b.N; i++ {
   335  		if _, err := InterfaceByName(ifi.Name); err != nil {
   336  			b.Fatal(err)
   337  		}
   338  	}
   339  }
   340  
   341  func BenchmarkInterfaceAddrs(b *testing.B) {
   342  	testHookUninstaller.Do(uninstallTestHooks)
   343  
   344  	for i := 0; i < b.N; i++ {
   345  		if _, err := InterfaceAddrs(); err != nil {
   346  			b.Fatal(err)
   347  		}
   348  	}
   349  }
   350  
   351  func BenchmarkInterfacesAndAddrs(b *testing.B) {
   352  	testHookUninstaller.Do(uninstallTestHooks)
   353  
   354  	ifi := loopbackInterface()
   355  	if ifi == nil {
   356  		b.Skip("loopback interface not found")
   357  	}
   358  	for i := 0; i < b.N; i++ {
   359  		if _, err := ifi.Addrs(); err != nil {
   360  			b.Fatal(err)
   361  		}
   362  	}
   363  }
   364  
   365  func BenchmarkInterfacesAndMulticastAddrs(b *testing.B) {
   366  	testHookUninstaller.Do(uninstallTestHooks)
   367  
   368  	ifi := loopbackInterface()
   369  	if ifi == nil {
   370  		b.Skip("loopback interface not found")
   371  	}
   372  	for i := 0; i < b.N; i++ {
   373  		if _, err := ifi.MulticastAddrs(); err != nil {
   374  			b.Fatal(err)
   375  		}
   376  	}
   377  }
   378  

View as plain text