netlink_linux_test.go

package ipvs

import (
	"errors"
	"net"
	"reflect"
	"syscall"
	"testing"

	"github.com/vishvananda/netlink/nl"
	"golang.org/x/sys/unix"
)

// unknownAttrType represents an unrecognized netlink attribute,
// used to verify that unknown attributes are ignored.
const unknownAttrType = 0x7fff

func Test_getIPFamily(t *testing.T) {
	testcases := []struct {
		name           string
		address        []byte
		expectedFamily uint16
		expectedErr    error
	}{
		{
			name:           "16 byte IPv4 10.0.0.1",
			address:        []byte{10, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			expectedFamily: syscall.AF_INET,
			expectedErr:    nil,
		},
		{
			name:           "16 byte IPv6 2001:db8:3c4d:15::1a00",
			address:        []byte{32, 1, 13, 184, 60, 77, 0, 21, 0, 0, 0, 0, 0, 0, 26, 0},
			expectedFamily: syscall.AF_INET6,
			expectedErr:    nil,
		},
		{
			name:           "zero address",
			address:        []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			expectedFamily: 0,
			expectedErr:    errors.New("could not parse IP family from address data"),
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			family, err := getIPFamily(tc.address)
			if !reflect.DeepEqual(err, tc.expectedErr) {
				t.Logf("got err: %v", err)
				t.Logf("expected err: %v", tc.expectedErr)
				t.Errorf("unexpected error")
			}

			if family != tc.expectedFamily {
				t.Logf("got IP family: %v", family)
				t.Logf("expected IP family: %v", tc.expectedFamily)
				t.Errorf("unexpected IP family")
			}
		})
	}
}

func Test_AssembleService(t *testing.T) {
	tests := []struct {
		name  string
		attrs []syscall.NetlinkRouteAttr
		want  Service
	}{
		{
			name: "IPv4 service",
			attrs: []syscall.NetlinkRouteAttr{
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrAddress)},
					Value: net.IPv4(192, 0, 2, 1).To4(),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrAddressFamily)},
					Value: nl.Uint16Attr(unix.AF_INET),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrProtocol)},
					Value: nl.Uint16Attr(unix.IPPROTO_TCP),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrPort)},
					Value: []byte{0x00, 0x50},
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrSchedName)},
					Value: nl.ZeroTerminated("rr"),
				},
				{
					// Unknown attributes should be ignored for forward compatibility.
					Attr:  syscall.RtAttr{Type: unknownAttrType},
					Value: []byte{1, 2, 3, 4},
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrPEName)},
					Value: nl.ZeroTerminated("sip"),
				},
			},
			want: Service{
				AddressFamily: unix.AF_INET,
				Address:       net.IPv4(192, 0, 2, 1).To4(),
				Protocol:      unix.IPPROTO_TCP,
				Port:          80,
				SchedName:     "rr",
				PEName:        "sip",
			},
		},
		{
			name: "IPv6 service",
			attrs: []syscall.NetlinkRouteAttr{
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrAddressFamily)},
					Value: nl.Uint16Attr(unix.AF_INET6),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsSvcAttrAddress)},
					Value: net.ParseIP("2001:db8::1").To16(),
				},
			},
			want: Service{
				AddressFamily: unix.AF_INET6,
				Address:       net.ParseIP("2001:db8::1"),
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := assembleService(tc.attrs)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*got, tc.want) {
				t.Errorf("assembleService() = %+v, want %+v", *got, tc.want)
			}
		})
	}
}

func Test_AssembleDestination(t *testing.T) {
	tests := []struct {
		name  string
		attrs []syscall.NetlinkRouteAttr
		want  Destination
	}{
		{
			name: "IPv4 destination",
			attrs: []syscall.NetlinkRouteAttr{
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrAddress)},
					Value: net.IPv4(192, 0, 2, 2).To4(),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrAddressFamily)},
					Value: nl.Uint16Attr(unix.AF_INET),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrPort)},
					Value: []byte{0x1f, 0x90},
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrWeight)},
					Value: nl.Uint32Attr(65536),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrActiveConnections)},
					Value: nl.Uint32Attr(10),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrInactiveConnections)},
					Value: nl.Uint32Attr(20),
				},
				{
					// Unknown attributes should be ignored for forward compatibility.
					Attr:  syscall.RtAttr{Type: unknownAttrType},
					Value: []byte{1, 2, 3, 4},
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrPersistentConnections)},
					Value: nl.Uint32Attr(30),
				},
			},
			want: Destination{
				AddressFamily:         unix.AF_INET,
				Address:               net.IPv4(192, 0, 2, 2).To4(),
				Port:                  8080,
				Weight:                65536,
				ActiveConnections:     10,
				InactiveConnections:   20,
				PersistentConnections: 30,
			},
		},
		{
			name: "IPv6 destination",
			attrs: []syscall.NetlinkRouteAttr{
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrAddressFamily)},
					Value: nl.Uint16Attr(unix.AF_INET6),
				},
				{
					Attr:  syscall.RtAttr{Type: uint16(ipvsDestAttrAddress)},
					Value: net.ParseIP("2001:db8::2").To16(),
				},
			},
			want: Destination{
				AddressFamily: unix.AF_INET6,
				Address:       net.ParseIP("2001:db8::2"),
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := assembleDestination(tc.attrs)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*got, tc.want) {
				t.Errorf("assembleDestination() = %+v, want %+v", *got, tc.want)
			}
		})
	}
}

func Test_AssembleStats(t *testing.T) {
	tests := []struct {
		name  string
		attr  ipvsStats
		value []byte
		want  SvcStats
	}{
		{
			name:  "connections",
			attr:  ipvsStatsConns,
			value: nl.Uint32Attr(65536),
			want:  SvcStats{Connections: 65536},
		},
		{
			name:  "packets in",
			attr:  ipvsStatsPktsIn,
			value: nl.Uint32Attr(123456),
			want:  SvcStats{PacketsIn: 123456},
		},
		{
			name:  "packets out",
			attr:  ipvsStatsPktsOut,
			value: nl.Uint32Attr(234567),
			want:  SvcStats{PacketsOut: 234567},
		},
		{
			name:  "bytes in",
			attr:  ipvsStatsBytesIn,
			value: nl.Uint64Attr(1 << 40),
			want:  SvcStats{BytesIn: 1 << 40},
		},
		{
			name:  "bytes out",
			attr:  ipvsStatsBytesOut,
			value: nl.Uint64Attr(1 << 41),
			want:  SvcStats{BytesOut: 1 << 41},
		},
		{
			name:  "connections per second",
			attr:  ipvsStatsCPS,
			value: nl.Uint32Attr(100),
			want:  SvcStats{CPS: 100},
		},
		{
			name:  "packets in per second",
			attr:  ipvsStatsPPSIn,
			value: nl.Uint32Attr(200),
			want:  SvcStats{PPSIn: 200},
		},
		{
			name:  "packets out per second",
			attr:  ipvsStatsPPSOut,
			value: nl.Uint32Attr(300),
			want:  SvcStats{PPSOut: 300},
		},
		{
			name:  "bytes in per second",
			attr:  ipvsStatsBPSIn,
			value: nl.Uint32Attr(400),
			want:  SvcStats{BPSIn: 400},
		},
		{
			name:  "bytes out per second",
			attr:  ipvsStatsBPSOut,
			value: nl.Uint32Attr(500),
			want:  SvcStats{BPSOut: 500},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			attr := nl.NewRtAttr(int(tc.attr), tc.value)

			got, err := assembleStats(attr.Serialize())
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("assembleStats() = %+v, want %+v", got, tc.want)
			}
		})
	}

	t.Run("unknown attribute", func(t *testing.T) {
		// Unknown attributes must not prevent subsequent attributes
		// from being decoded.
		unknown := nl.NewRtAttr(unknownAttrType, []byte{1, 2, 3, 4})
		known := nl.NewRtAttr(int(ipvsStatsConns), nl.Uint32Attr(123))

		msg := append(unknown.Serialize(), known.Serialize()...)
		got, err := assembleStats(msg)
		if err != nil {
			t.Fatal(err)
		}
		want := SvcStats{Connections: 123}
		if !reflect.DeepEqual(got, want) {
			t.Errorf("assembleStats() = %+v, want %+v", got, want)
		}
	})

	t.Run("malformed attribute", func(t *testing.T) {
		// The attribute header claims more bytes than are available.
		msg := make([]byte, 4)
		native.PutUint16(msg[:2], 8)
		native.PutUint16(msg[2:], uint16(ipvsStatsConns))

		_, err := assembleStats(msg)
		if err == nil {
			t.Fatal("assembleStats() expected an error for malformed attribute")
		}
	})
}