mirror of
https://github.com/moby/moby.git
synced 2026-07-11 18:13:57 +00:00
3775939303
GenerateRandomName now uses length to represent the overall length of the string; this will help future users avoid creating interface names that are too long for the kernel to accept by mistake. The test coverage is increased and cleaned up using gotest.tools. Signed-off-by: Bjorn Neergaard <bneergaard@mirantis.com>
390 lines
10 KiB
Go
390 lines
10 KiB
Go
package netutils
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"net"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/docker/libnetwork/ipamutils"
|
|
"github.com/docker/docker/libnetwork/testutils"
|
|
"github.com/docker/docker/libnetwork/types"
|
|
"github.com/vishvananda/netlink"
|
|
"gotest.tools/v3/assert"
|
|
is "gotest.tools/v3/assert/cmp"
|
|
)
|
|
|
|
func TestNonOverlappingNameservers(t *testing.T) {
|
|
network := &net.IPNet{
|
|
IP: []byte{192, 168, 0, 1},
|
|
Mask: []byte{255, 255, 255, 0},
|
|
}
|
|
nameservers := []string{
|
|
"127.0.0.1/32",
|
|
}
|
|
|
|
if err := CheckNameserverOverlaps(nameservers, network); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestOverlappingNameservers(t *testing.T) {
|
|
network := &net.IPNet{
|
|
IP: []byte{192, 168, 0, 1},
|
|
Mask: []byte{255, 255, 255, 0},
|
|
}
|
|
nameservers := []string{
|
|
"192.168.0.1/32",
|
|
}
|
|
|
|
if err := CheckNameserverOverlaps(nameservers, network); err == nil {
|
|
t.Fatalf("Expected error %s got %s", ErrNetworkOverlapsWithNameservers, err)
|
|
}
|
|
}
|
|
|
|
func TestCheckRouteOverlaps(t *testing.T) {
|
|
networkGetRoutesFct = func(netlink.Link, int) ([]netlink.Route, error) {
|
|
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"}
|
|
routes := []netlink.Route{}
|
|
for _, addr := range routesData {
|
|
_, netX, _ := net.ParseCIDR(addr)
|
|
routes = append(routes, netlink.Route{Dst: netX, Scope: netlink.SCOPE_LINK})
|
|
}
|
|
// Add a route with a scope which should not overlap
|
|
_, netX, _ := net.ParseCIDR("10.0.5.0/24")
|
|
routes = append(routes, netlink.Route{Dst: netX, Scope: netlink.SCOPE_UNIVERSE})
|
|
return routes, nil
|
|
}
|
|
defer func() { networkGetRoutesFct = nil }()
|
|
|
|
_, netX, _ := net.ParseCIDR("172.16.0.1/24")
|
|
if err := CheckRouteOverlaps(netX); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, netX, _ = net.ParseCIDR("10.0.2.0/24")
|
|
if err := CheckRouteOverlaps(netX); err == nil {
|
|
t.Fatal("10.0.2.0/24 and 10.0.2.0 should overlap but it doesn't")
|
|
}
|
|
|
|
_, netX, _ = net.ParseCIDR("10.0.5.0/24")
|
|
if err := CheckRouteOverlaps(netX); err != nil {
|
|
t.Fatal("10.0.5.0/24 and 10.0.5.0 with scope UNIVERSE should not overlap but it does")
|
|
}
|
|
}
|
|
|
|
func TestCheckNameserverOverlaps(t *testing.T) {
|
|
nameservers := []string{"10.0.2.3/32", "192.168.102.1/32"}
|
|
|
|
_, netX, _ := net.ParseCIDR("10.0.2.3/32")
|
|
|
|
if err := CheckNameserverOverlaps(nameservers, netX); err == nil {
|
|
t.Fatalf("%s should overlap 10.0.2.3/32 but doesn't", netX)
|
|
}
|
|
|
|
_, netX, _ = net.ParseCIDR("192.168.102.2/32")
|
|
|
|
if err := CheckNameserverOverlaps(nameservers, netX); err != nil {
|
|
t.Fatalf("%s should not overlap %v but it does", netX, nameservers)
|
|
}
|
|
}
|
|
|
|
func AssertOverlap(CIDRx string, CIDRy string, t *testing.T) {
|
|
_, netX, _ := net.ParseCIDR(CIDRx)
|
|
_, netY, _ := net.ParseCIDR(CIDRy)
|
|
if !NetworkOverlaps(netX, netY) {
|
|
t.Errorf("%v and %v should overlap", netX, netY)
|
|
}
|
|
}
|
|
|
|
func AssertNoOverlap(CIDRx string, CIDRy string, t *testing.T) {
|
|
_, netX, _ := net.ParseCIDR(CIDRx)
|
|
_, netY, _ := net.ParseCIDR(CIDRy)
|
|
if NetworkOverlaps(netX, netY) {
|
|
t.Errorf("%v and %v should not overlap", netX, netY)
|
|
}
|
|
}
|
|
|
|
func TestNetworkOverlaps(t *testing.T) {
|
|
//netY starts at same IP and ends within netX
|
|
AssertOverlap("172.16.0.1/24", "172.16.0.1/25", t)
|
|
//netY starts within netX and ends at same IP
|
|
AssertOverlap("172.16.0.1/24", "172.16.0.128/25", t)
|
|
//netY starts and ends within netX
|
|
AssertOverlap("172.16.0.1/24", "172.16.0.64/25", t)
|
|
//netY starts at same IP and ends outside of netX
|
|
AssertOverlap("172.16.0.1/24", "172.16.0.1/23", t)
|
|
//netY starts before and ends at same IP of netX
|
|
AssertOverlap("172.16.1.1/24", "172.16.0.1/23", t)
|
|
//netY starts before and ends outside of netX
|
|
AssertOverlap("172.16.1.1/24", "172.16.0.1/22", t)
|
|
//netY starts and ends before netX
|
|
AssertNoOverlap("172.16.1.1/25", "172.16.0.1/24", t)
|
|
//netX starts and ends before netY
|
|
AssertNoOverlap("172.16.1.1/25", "172.16.2.1/24", t)
|
|
}
|
|
|
|
func TestNetworkRange(t *testing.T) {
|
|
// Simple class C test
|
|
_, network, _ := net.ParseCIDR("192.168.0.1/24")
|
|
first, last := NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("192.168.0.0")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("192.168.0.255")) {
|
|
t.Error(last.String())
|
|
}
|
|
|
|
// Class A test
|
|
_, network, _ = net.ParseCIDR("10.0.0.1/8")
|
|
first, last = NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("10.0.0.0")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("10.255.255.255")) {
|
|
t.Error(last.String())
|
|
}
|
|
|
|
// Class A, random IP address
|
|
_, network, _ = net.ParseCIDR("10.1.2.3/8")
|
|
first, last = NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("10.0.0.0")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("10.255.255.255")) {
|
|
t.Error(last.String())
|
|
}
|
|
|
|
// 32bit mask
|
|
_, network, _ = net.ParseCIDR("10.1.2.3/32")
|
|
first, last = NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("10.1.2.3")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("10.1.2.3")) {
|
|
t.Error(last.String())
|
|
}
|
|
|
|
// 31bit mask
|
|
_, network, _ = net.ParseCIDR("10.1.2.3/31")
|
|
first, last = NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("10.1.2.2")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("10.1.2.3")) {
|
|
t.Error(last.String())
|
|
}
|
|
|
|
// 26bit mask
|
|
_, network, _ = net.ParseCIDR("10.1.2.3/26")
|
|
first, last = NetworkRange(network)
|
|
if !first.Equal(net.ParseIP("10.1.2.0")) {
|
|
t.Error(first.String())
|
|
}
|
|
if !last.Equal(net.ParseIP("10.1.2.63")) {
|
|
t.Error(last.String())
|
|
}
|
|
}
|
|
|
|
// Test veth name generation "veth"+rand (e.g.veth0f60e2c)
|
|
func TestGenerateRandomName(t *testing.T) {
|
|
const vethPrefix = "veth"
|
|
const vethLen = len(vethPrefix) + 7
|
|
|
|
testCases := []struct {
|
|
prefix string
|
|
length int
|
|
error bool
|
|
}{
|
|
{vethPrefix, -1, true},
|
|
{vethPrefix, 0, true},
|
|
{vethPrefix, len(vethPrefix) - 1, true},
|
|
{vethPrefix, len(vethPrefix), true},
|
|
{vethPrefix, len(vethPrefix) + 1, false},
|
|
{vethPrefix, 255, false},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(fmt.Sprintf("prefix=%s/length=%d", tc.prefix, tc.length), func(t *testing.T) {
|
|
name, err := GenerateRandomName(tc.prefix, tc.length)
|
|
if tc.error {
|
|
assert.Check(t, is.ErrorContains(err, "invalid length"))
|
|
} else {
|
|
assert.NilError(t, err)
|
|
assert.Check(t, strings.HasPrefix(name, tc.prefix), "Expected name to start with %s", tc.prefix)
|
|
assert.Check(t, is.Equal(len(name), tc.length), "Expected %d characters, instead received %d characters", tc.length, len(name))
|
|
}
|
|
})
|
|
}
|
|
|
|
var randomNames [16]string
|
|
for i := range randomNames {
|
|
randomName, err := GenerateRandomName(vethPrefix, vethLen)
|
|
assert.NilError(t, err)
|
|
|
|
for _, oldName := range randomNames {
|
|
if randomName == oldName {
|
|
t.Fatalf("Duplicate random name generated: %s", randomName)
|
|
}
|
|
}
|
|
|
|
randomNames[i] = randomName
|
|
}
|
|
}
|
|
|
|
// Test mac generation.
|
|
func TestUtilGenerateRandomMAC(t *testing.T) {
|
|
mac1 := GenerateRandomMAC()
|
|
mac2 := GenerateRandomMAC()
|
|
// ensure bytes are unique
|
|
if bytes.Equal(mac1, mac2) {
|
|
t.Fatalf("mac1 %s should not equal mac2 %s", mac1, mac2)
|
|
}
|
|
// existing tests check string functionality so keeping the pattern
|
|
if mac1.String() == mac2.String() {
|
|
t.Fatalf("mac1 %s should not equal mac2 %s", mac1, mac2)
|
|
}
|
|
}
|
|
|
|
func TestNetworkRequest(t *testing.T) {
|
|
defer testutils.SetupTestOSContext(t)()
|
|
|
|
nw, err := FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var found bool
|
|
for _, exp := range ipamutils.PredefinedLocalScopeDefaultNetworks {
|
|
if types.CompareIPNet(exp, nw) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
t.Fatalf("Found unexpected broad network %s", nw)
|
|
}
|
|
|
|
nw, err = FindAvailableNetwork(ipamutils.PredefinedGlobalScopeDefaultNetworks)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
found = false
|
|
for _, exp := range ipamutils.PredefinedGlobalScopeDefaultNetworks {
|
|
if types.CompareIPNet(exp, nw) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
t.Fatalf("Found unexpected granular network %s", nw)
|
|
}
|
|
|
|
// Add iface and ssert returned address on request
|
|
createInterface(t, "test", "172.17.42.1/16")
|
|
|
|
_, exp, err := net.ParseCIDR("172.18.0.0/16")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
nw, err = FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !types.CompareIPNet(exp, nw) {
|
|
t.Fatalf("expected %s. got %s", exp, nw)
|
|
}
|
|
}
|
|
|
|
func TestElectInterfaceAddressMultipleAddresses(t *testing.T) {
|
|
defer testutils.SetupTestOSContext(t)()
|
|
|
|
nws := []string{"172.101.202.254/16", "172.102.202.254/16"}
|
|
createInterface(t, "test", nws...)
|
|
|
|
ipv4NwList, ipv6NwList, err := ElectInterfaceAddresses("test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(ipv4NwList) == 0 {
|
|
t.Fatal("unexpected empty ipv4 network addresses")
|
|
}
|
|
|
|
if len(ipv6NwList) == 0 {
|
|
t.Fatal("unexpected empty ipv6 network addresses")
|
|
}
|
|
|
|
nwList := []string{}
|
|
for _, ipv4Nw := range ipv4NwList {
|
|
nwList = append(nwList, ipv4Nw.String())
|
|
}
|
|
sort.Strings(nws)
|
|
sort.Strings(nwList)
|
|
|
|
if len(nws) != len(nwList) {
|
|
t.Fatalf("expected %v. got %v", nws, nwList)
|
|
}
|
|
for i, nw := range nws {
|
|
if nw != nwList[i] {
|
|
t.Fatalf("expected %v. got %v", nw, nwList[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestElectInterfaceAddress(t *testing.T) {
|
|
defer testutils.SetupTestOSContext(t)()
|
|
|
|
nws := "172.101.202.254/16"
|
|
createInterface(t, "test", nws)
|
|
|
|
ipv4Nw, ipv6Nw, err := ElectInterfaceAddresses("test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(ipv4Nw) == 0 {
|
|
t.Fatal("unexpected empty ipv4 network addresses")
|
|
}
|
|
|
|
if len(ipv6Nw) == 0 {
|
|
t.Fatal("unexpected empty ipv6 network addresses")
|
|
}
|
|
|
|
if nws != ipv4Nw[0].String() {
|
|
t.Fatalf("expected %s. got %s", nws, ipv4Nw[0])
|
|
}
|
|
}
|
|
|
|
func createInterface(t *testing.T, name string, nws ...string) {
|
|
// Add interface
|
|
link := &netlink.Bridge{
|
|
LinkAttrs: netlink.LinkAttrs{
|
|
Name: "test",
|
|
},
|
|
}
|
|
bips := []*net.IPNet{}
|
|
for _, nw := range nws {
|
|
bip, err := types.ParseCIDR(nw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
bips = append(bips, bip)
|
|
}
|
|
if err := netlink.LinkAdd(link); err != nil {
|
|
t.Fatalf("Failed to create interface via netlink: %v", err)
|
|
}
|
|
for _, bip := range bips {
|
|
if err := netlink.AddrAdd(link, &netlink.Addr{IPNet: bip}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := netlink.LinkSetUp(link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|