github.com/jfrazelle/docker@v1.1.2-0.20210712172922-bf78e25fe508/libnetwork/netutils/utils_linux_test.go (about)

     1  package netutils
     2  
     3  import (
     4  	"bytes"
     5  	"net"
     6  	"sort"
     7  	"testing"
     8  
     9  	"github.com/docker/docker/libnetwork/ipamutils"
    10  	"github.com/docker/docker/libnetwork/testutils"
    11  	"github.com/docker/docker/libnetwork/types"
    12  	"github.com/vishvananda/netlink"
    13  )
    14  
    15  func TestNonOverlappingNameservers(t *testing.T) {
    16  	network := &net.IPNet{
    17  		IP:   []byte{192, 168, 0, 1},
    18  		Mask: []byte{255, 255, 255, 0},
    19  	}
    20  	nameservers := []string{
    21  		"127.0.0.1/32",
    22  	}
    23  
    24  	if err := CheckNameserverOverlaps(nameservers, network); err != nil {
    25  		t.Fatal(err)
    26  	}
    27  }
    28  
    29  func TestOverlappingNameservers(t *testing.T) {
    30  	network := &net.IPNet{
    31  		IP:   []byte{192, 168, 0, 1},
    32  		Mask: []byte{255, 255, 255, 0},
    33  	}
    34  	nameservers := []string{
    35  		"192.168.0.1/32",
    36  	}
    37  
    38  	if err := CheckNameserverOverlaps(nameservers, network); err == nil {
    39  		t.Fatalf("Expected error %s got %s", ErrNetworkOverlapsWithNameservers, err)
    40  	}
    41  }
    42  
    43  func TestCheckRouteOverlaps(t *testing.T) {
    44  	networkGetRoutesFct = func(netlink.Link, int) ([]netlink.Route, error) {
    45  		routesData := []string{"10.0.2.0/32", "10.0.3.0/24", "10.0.42.0/24", "172.16.42.0/24", "192.168.142.0/24"}
    46  		routes := []netlink.Route{}
    47  		for _, addr := range routesData {
    48  			_, netX, _ := net.ParseCIDR(addr)
    49  			routes = append(routes, netlink.Route{Dst: netX})
    50  		}
    51  		return routes, nil
    52  	}
    53  	defer func() { networkGetRoutesFct = nil }()
    54  
    55  	_, netX, _ := net.ParseCIDR("172.16.0.1/24")
    56  	if err := CheckRouteOverlaps(netX); err != nil {
    57  		t.Fatal(err)
    58  	}
    59  
    60  	_, netX, _ = net.ParseCIDR("10.0.2.0/24")
    61  	if err := CheckRouteOverlaps(netX); err == nil {
    62  		t.Fatal("10.0.2.0/24 and 10.0.2.0 should overlap but it doesn't")
    63  	}
    64  }
    65  
    66  func TestCheckNameserverOverlaps(t *testing.T) {
    67  	nameservers := []string{"10.0.2.3/32", "192.168.102.1/32"}
    68  
    69  	_, netX, _ := net.ParseCIDR("10.0.2.3/32")
    70  
    71  	if err := CheckNameserverOverlaps(nameservers, netX); err == nil {
    72  		t.Fatalf("%s should overlap 10.0.2.3/32 but doesn't", netX)
    73  	}
    74  
    75  	_, netX, _ = net.ParseCIDR("192.168.102.2/32")
    76  
    77  	if err := CheckNameserverOverlaps(nameservers, netX); err != nil {
    78  		t.Fatalf("%s should not overlap %v but it does", netX, nameservers)
    79  	}
    80  }
    81  
    82  func AssertOverlap(CIDRx string, CIDRy string, t *testing.T) {
    83  	_, netX, _ := net.ParseCIDR(CIDRx)
    84  	_, netY, _ := net.ParseCIDR(CIDRy)
    85  	if !NetworkOverlaps(netX, netY) {
    86  		t.Errorf("%v and %v should overlap", netX, netY)
    87  	}
    88  }
    89  
    90  func AssertNoOverlap(CIDRx string, CIDRy string, t *testing.T) {
    91  	_, netX, _ := net.ParseCIDR(CIDRx)
    92  	_, netY, _ := net.ParseCIDR(CIDRy)
    93  	if NetworkOverlaps(netX, netY) {
    94  		t.Errorf("%v and %v should not overlap", netX, netY)
    95  	}
    96  }
    97  
    98  func TestNetworkOverlaps(t *testing.T) {
    99  	//netY starts at same IP and ends within netX
   100  	AssertOverlap("172.16.0.1/24", "172.16.0.1/25", t)
   101  	//netY starts within netX and ends at same IP
   102  	AssertOverlap("172.16.0.1/24", "172.16.0.128/25", t)
   103  	//netY starts and ends within netX
   104  	AssertOverlap("172.16.0.1/24", "172.16.0.64/25", t)
   105  	//netY starts at same IP and ends outside of netX
   106  	AssertOverlap("172.16.0.1/24", "172.16.0.1/23", t)
   107  	//netY starts before and ends at same IP of netX
   108  	AssertOverlap("172.16.1.1/24", "172.16.0.1/23", t)
   109  	//netY starts before and ends outside of netX
   110  	AssertOverlap("172.16.1.1/24", "172.16.0.1/22", t)
   111  	//netY starts and ends before netX
   112  	AssertNoOverlap("172.16.1.1/25", "172.16.0.1/24", t)
   113  	//netX starts and ends before netY
   114  	AssertNoOverlap("172.16.1.1/25", "172.16.2.1/24", t)
   115  }
   116  
   117  func TestNetworkRange(t *testing.T) {
   118  	// Simple class C test
   119  	_, network, _ := net.ParseCIDR("192.168.0.1/24")
   120  	first, last := NetworkRange(network)
   121  	if !first.Equal(net.ParseIP("192.168.0.0")) {
   122  		t.Error(first.String())
   123  	}
   124  	if !last.Equal(net.ParseIP("192.168.0.255")) {
   125  		t.Error(last.String())
   126  	}
   127  
   128  	// Class A test
   129  	_, network, _ = net.ParseCIDR("10.0.0.1/8")
   130  	first, last = NetworkRange(network)
   131  	if !first.Equal(net.ParseIP("10.0.0.0")) {
   132  		t.Error(first.String())
   133  	}
   134  	if !last.Equal(net.ParseIP("10.255.255.255")) {
   135  		t.Error(last.String())
   136  	}
   137  
   138  	// Class A, random IP address
   139  	_, network, _ = net.ParseCIDR("10.1.2.3/8")
   140  	first, last = NetworkRange(network)
   141  	if !first.Equal(net.ParseIP("10.0.0.0")) {
   142  		t.Error(first.String())
   143  	}
   144  	if !last.Equal(net.ParseIP("10.255.255.255")) {
   145  		t.Error(last.String())
   146  	}
   147  
   148  	// 32bit mask
   149  	_, network, _ = net.ParseCIDR("10.1.2.3/32")
   150  	first, last = NetworkRange(network)
   151  	if !first.Equal(net.ParseIP("10.1.2.3")) {
   152  		t.Error(first.String())
   153  	}
   154  	if !last.Equal(net.ParseIP("10.1.2.3")) {
   155  		t.Error(last.String())
   156  	}
   157  
   158  	// 31bit mask
   159  	_, network, _ = net.ParseCIDR("10.1.2.3/31")
   160  	first, last = NetworkRange(network)
   161  	if !first.Equal(net.ParseIP("10.1.2.2")) {
   162  		t.Error(first.String())
   163  	}
   164  	if !last.Equal(net.ParseIP("10.1.2.3")) {
   165  		t.Error(last.String())
   166  	}
   167  
   168  	// 26bit mask
   169  	_, network, _ = net.ParseCIDR("10.1.2.3/26")
   170  	first, last = NetworkRange(network)
   171  	if !first.Equal(net.ParseIP("10.1.2.0")) {
   172  		t.Error(first.String())
   173  	}
   174  	if !last.Equal(net.ParseIP("10.1.2.63")) {
   175  		t.Error(last.String())
   176  	}
   177  }
   178  
   179  // Test veth name generation "veth"+rand (e.g.veth0f60e2c)
   180  func TestGenerateRandomName(t *testing.T) {
   181  	name1, err := GenerateRandomName("veth", 7)
   182  	if err != nil {
   183  		t.Fatal(err)
   184  	}
   185  	// veth plus generated append equals a len of 11
   186  	if len(name1) != 11 {
   187  		t.Fatalf("Expected 11 characters, instead received %d characters", len(name1))
   188  	}
   189  	name2, err := GenerateRandomName("veth", 7)
   190  	if err != nil {
   191  		t.Fatal(err)
   192  	}
   193  	// Fail if the random generated names equal one another
   194  	if name1 == name2 {
   195  		t.Fatalf("Expected differing values but received %s and %s", name1, name2)
   196  	}
   197  }
   198  
   199  // Test mac generation.
   200  func TestUtilGenerateRandomMAC(t *testing.T) {
   201  	mac1 := GenerateRandomMAC()
   202  	mac2 := GenerateRandomMAC()
   203  	// ensure bytes are unique
   204  	if bytes.Equal(mac1, mac2) {
   205  		t.Fatalf("mac1 %s should not equal mac2 %s", mac1, mac2)
   206  	}
   207  	// existing tests check string functionality so keeping the pattern
   208  	if mac1.String() == mac2.String() {
   209  		t.Fatalf("mac1 %s should not equal mac2 %s", mac1, mac2)
   210  	}
   211  }
   212  
   213  func TestNetworkRequest(t *testing.T) {
   214  	defer testutils.SetupTestOSContext(t)()
   215  
   216  	nw, err := FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
   217  	if err != nil {
   218  		t.Fatal(err)
   219  	}
   220  
   221  	var found bool
   222  	for _, exp := range ipamutils.PredefinedLocalScopeDefaultNetworks {
   223  		if types.CompareIPNet(exp, nw) {
   224  			found = true
   225  			break
   226  		}
   227  	}
   228  
   229  	if !found {
   230  		t.Fatalf("Found unexpected broad network %s", nw)
   231  	}
   232  
   233  	nw, err = FindAvailableNetwork(ipamutils.PredefinedGlobalScopeDefaultNetworks)
   234  	if err != nil {
   235  		t.Fatal(err)
   236  	}
   237  
   238  	found = false
   239  	for _, exp := range ipamutils.PredefinedGlobalScopeDefaultNetworks {
   240  		if types.CompareIPNet(exp, nw) {
   241  			found = true
   242  			break
   243  		}
   244  	}
   245  
   246  	if !found {
   247  		t.Fatalf("Found unexpected granular network %s", nw)
   248  	}
   249  
   250  	// Add iface and ssert returned address on request
   251  	createInterface(t, "test", "172.17.42.1/16")
   252  
   253  	_, exp, err := net.ParseCIDR("172.18.0.0/16")
   254  	if err != nil {
   255  		t.Fatal(err)
   256  	}
   257  	nw, err = FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
   258  	if err != nil {
   259  		t.Fatal(err)
   260  	}
   261  	if !types.CompareIPNet(exp, nw) {
   262  		t.Fatalf("expected %s. got %s", exp, nw)
   263  	}
   264  }
   265  
   266  func TestElectInterfaceAddressMultipleAddresses(t *testing.T) {
   267  	defer testutils.SetupTestOSContext(t)()
   268  
   269  	nws := []string{"172.101.202.254/16", "172.102.202.254/16"}
   270  	createInterface(t, "test", nws...)
   271  
   272  	ipv4NwList, ipv6NwList, err := ElectInterfaceAddresses("test")
   273  	if err != nil {
   274  		t.Fatal(err)
   275  	}
   276  
   277  	if len(ipv4NwList) == 0 {
   278  		t.Fatal("unexpected empty ipv4 network addresses")
   279  	}
   280  
   281  	if len(ipv6NwList) == 0 {
   282  		t.Fatal("unexpected empty ipv6 network addresses")
   283  	}
   284  
   285  	nwList := []string{}
   286  	for _, ipv4Nw := range ipv4NwList {
   287  		nwList = append(nwList, ipv4Nw.String())
   288  	}
   289  	sort.Strings(nws)
   290  	sort.Strings(nwList)
   291  
   292  	if len(nws) != len(nwList) {
   293  		t.Fatalf("expected %v. got %v", nws, nwList)
   294  	}
   295  	for i, nw := range nws {
   296  		if nw != nwList[i] {
   297  			t.Fatalf("expected %v. got %v", nw, nwList[i])
   298  		}
   299  	}
   300  }
   301  
   302  func TestElectInterfaceAddress(t *testing.T) {
   303  	defer testutils.SetupTestOSContext(t)()
   304  
   305  	nws := "172.101.202.254/16"
   306  	createInterface(t, "test", nws)
   307  
   308  	ipv4Nw, ipv6Nw, err := ElectInterfaceAddresses("test")
   309  	if err != nil {
   310  		t.Fatal(err)
   311  	}
   312  
   313  	if len(ipv4Nw) == 0 {
   314  		t.Fatal("unexpected empty ipv4 network addresses")
   315  	}
   316  
   317  	if len(ipv6Nw) == 0 {
   318  		t.Fatal("unexpected empty ipv6 network addresses")
   319  	}
   320  
   321  	if nws != ipv4Nw[0].String() {
   322  		t.Fatalf("expected %s. got %s", nws, ipv4Nw[0])
   323  	}
   324  }
   325  
   326  func createInterface(t *testing.T, name string, nws ...string) {
   327  	// Add interface
   328  	link := &netlink.Bridge{
   329  		LinkAttrs: netlink.LinkAttrs{
   330  			Name: "test",
   331  		},
   332  	}
   333  	bips := []*net.IPNet{}
   334  	for _, nw := range nws {
   335  		bip, err := types.ParseCIDR(nw)
   336  		if err != nil {
   337  			t.Fatal(err)
   338  		}
   339  		bips = append(bips, bip)
   340  	}
   341  	if err := netlink.LinkAdd(link); err != nil {
   342  		t.Fatalf("Failed to create interface via netlink: %v", err)
   343  	}
   344  	for _, bip := range bips {
   345  		if err := netlink.AddrAdd(link, &netlink.Addr{IPNet: bip}); err != nil {
   346  			t.Fatal(err)
   347  		}
   348  	}
   349  	if err := netlink.LinkSetUp(link); err != nil {
   350  		t.Fatal(err)
   351  	}
   352  }