492c09276d
We don't want to maintain backward compatibility for this package, so better make it an internal. Signed-off-by: Albin Kerouanton <albinker@gmail.com>
328 lines
8.7 KiB
Go
328 lines
8.7 KiB
Go
package netutils
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"net"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/docker/internal/testutils/netnsutils"
|
|
"github.com/docker/docker/libnetwork/ipamutils"
|
|
"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 netnsutils.SetupTestOSContext(t)()
|
|
|
|
nw, err := FindAvailableNetwork(ipamutils.GetLocalScopeDefaultNetworks())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var found bool
|
|
for _, exp := range ipamutils.GetLocalScopeDefaultNetworks() {
|
|
if types.CompareIPNet(exp, nw) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
t.Fatalf("Found unexpected broad network %s", nw)
|
|
}
|
|
|
|
nw, err = FindAvailableNetwork(ipamutils.GetGlobalScopeDefaultNetworks())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
found = false
|
|
for _, exp := range ipamutils.GetGlobalScopeDefaultNetworks() {
|
|
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.GetLocalScopeDefaultNetworks())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !types.CompareIPNet(exp, nw) {
|
|
t.Fatalf("expected %s. got %s", exp, nw)
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|