ISIS: Add support for router capability TLV

Author: Oliver Geiselhardt-Herms

protocols/isis/packet/tlv.go

@@ -77,6 +77,8 @@ func readTLV(buf *bytes.Buffer) (TLV, error) {
 		tlv, err = readISNeighborsTLV(buf, tlvType, tlvLength)
 	case LSPEntriesTLVType:
 		tlv, err = readLSPEntriesTLV(buf, tlvType, tlvLength)
+	case RouterCapabilityTLVType:
+		tlv, err = readRouterCapabilityTLV(buf, tlvType, tlvLength)
 	default:
 		tlv, err = readUnknownTLV(buf, tlvType, tlvLength)
 	}
@@ -87,3 +89,12 @@ func readTLV(buf *bytes.Buffer) (TLV, error) {
 
 	return tlv, nil
 }
+
+func copyTLVs(tlvs []TLV) []TLV {
+	ret := make([]TLV, 0, len(tlvs))
+	for _, tlv := range tlvs {
+		ret = append(ret, tlv.Copy())
+	}
+
+	return ret
+}

protocols/isis/packet/tlv_router_capability.go

@@ -0,0 +1,89 @@
+package packet
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/bio-routing/bio-rd/util/decode"
+	"github.com/bio-routing/tflow2/convert"
+)
+
+const RouterCapabilityTLVType = 242
+
+type RouterCapabilityTLV struct {
+	TLVType   uint8
+	TLVLength uint8
+	RouterID  uint32
+	Flags     uint8
+	SubTLVs   []TLV
+}
+
+const RouterCapabilityTLVLen = 7
+
+func readRouterCapabilityTLV(buf *bytes.Buffer, tlvType uint8, tlvLength uint8) (*RouterCapabilityTLV, error) {
+	pdu := &RouterCapabilityTLV{
+		TLVType:   tlvType,
+		TLVLength: tlvLength,
+	}
+	fields := []interface{}{
+		&pdu.RouterID,
+		&pdu.Flags,
+	}
+
+	err := decode.Decode(buf, fields)
+	if err != nil {
+		return nil, fmt.Errorf("unable to decode fields: %v", err)
+	}
+
+	toRead := tlvLength - RouterCapabilityTLVLen
+	if toRead > 0 {
+		tlvsBytes := make([]byte, toRead)
+		_, err := buf.Read(tlvsBytes)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read TLV bytes from buf: %w", err)
+		}
+
+		subTLVs, err := readTLVs(bytes.NewBuffer(tlvsBytes))
+		if err != nil {
+			return nil, fmt.Errorf("unable to decode sub TLVs: %w", err)
+		}
+
+		pdu.SubTLVs = subTLVs
+	}
+
+	return pdu, nil
+}
+
+func (r RouterCapabilityTLV) Copy() TLV {
+	ret := r
+	ret.SubTLVs = copyTLVs(r.SubTLVs)
+
+	return &ret
+}
+
+// Type returns the type of the TLV
+func (r RouterCapabilityTLV) Type() uint8 {
+	return r.TLVType
+}
+
+// Length returns the length of the TLV
+func (r RouterCapabilityTLV) Length() uint8 {
+	return r.TLVLength
+}
+
+// Value returns the TLV itself
+func (r RouterCapabilityTLV) Value() interface{} {
+	return r
+}
+
+// Serialize serializes an WriteByte into a buffer
+func (r RouterCapabilityTLV) Serialize(buf *bytes.Buffer) {
+	buf.WriteByte(r.TLVType)
+	buf.WriteByte(r.TLVLength)
+	buf.Write(convert.Uint32Byte(r.RouterID))
+	buf.WriteByte(r.Flags)
+
+	for i := range r.SubTLVs {
+		r.SubTLVs[i].Serialize(buf)
+	}
+}

protocols/isis/packet/tlv_router_capability_test.go

@@ -0,0 +1,112 @@
+package packet
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReadRouterCapabilityTLV(t *testing.T) {
+	tests := []struct {
+		name      string
+		tlvType   uint8
+		tlvLength uint8
+		input     []byte
+		expectErr bool
+		expected  *RouterCapabilityTLV
+	}{
+		{
+			name:      "empty input",
+			input:     []byte{},
+			expectErr: true,
+		},
+		{
+			name:      "valid input without sub TLVs",
+			input:     []byte{1, 2, 3, 4, 5},
+			expectErr: false,
+			expected: &RouterCapabilityTLV{
+				TLVType:   242,
+				TLVLength: 7,
+				RouterID:  0x01020304,
+				Flags:     5,
+				SubTLVs:   nil,
+			},
+		},
+		{
+			name:      "valid input with sub TLVs",
+			input:     []byte{1, 2, 3, 4, 5, 2, 1, 3},
+			expectErr: false,
+			expected: &RouterCapabilityTLV{
+				TLVType:   242,
+				TLVLength: 10,
+				RouterID:  0x01020304,
+				Flags:     5,
+				SubTLVs: []TLV{
+					&UnknownTLV{TLVType: 2, TLVLength: 1, TLVValue: []byte{3}},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := bytes.NewBuffer(tt.input)
+			result, err := readRouterCapabilityTLV(buf, 242, uint8(len(tt.input)+2))
+			if tt.expectErr && err == nil {
+				t.Errorf("expected error but got none for test case %s", tt.name)
+				return
+			}
+
+			if !tt.expectErr && err != nil {
+				t.Errorf("did not expect error but got: %v for test case %s", err, tt.name)
+				return
+			}
+
+			assert.Equal(t, tt.expected, result, tt.name)
+		})
+	}
+}
+
+func TestRouterCapabilityTLVSerialize(t *testing.T) {
+	tests := []struct {
+		name     string
+		tlv      *RouterCapabilityTLV
+		expected []byte
+	}{
+		{
+			name: "serialize without sub TLVs",
+			tlv: &RouterCapabilityTLV{
+				TLVType:   242,
+				TLVLength: 7,
+				RouterID:  0x01020304,
+				Flags:     5,
+				SubTLVs:   nil,
+			},
+			expected: []byte{242, 7, 1, 2, 3, 4, 5},
+		},
+		{
+			name: "serialize with sub TLVs",
+			tlv: &RouterCapabilityTLV{
+				TLVType:   242,
+				TLVLength: 10,
+				RouterID:  0x01020304,
+				Flags:     5,
+				SubTLVs: []TLV{
+					&UnknownTLV{TLVType: 2, TLVLength: 1, TLVValue: []byte{3}},
+				},
+			},
+			expected: []byte{242, 10, 1, 2, 3, 4, 5, 2, 1, 3},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := bytes.NewBuffer(nil)
+			tt.tlv.Serialize(buf)
+			result := buf.Bytes()
+
+			assert.Equal(t, tt.expected, result, tt.name)
+		})
+	}
+}