wip: ospv3 area 0

Author: mraerino

go.mod

@@ -16,6 +16,7 @@ require (
 	github.com/stretchr/testify v1.3.0
 	github.com/vishvananda/netlink v1.0.0
 	github.com/vishvananda/netns v0.0.0-20180720170159-13995c7128cc // indirect
+	golang.org/x/net v0.0.0-20190613194153-d28f0bde5980
 	google.golang.org/genproto v0.0.0-20181221175505-bd9b4fb69e2f // indirect
 	google.golang.org/grpc v1.17.0
 	gopkg.in/yaml.v2 v2.2.2

protocols/ospfv3/packet/common.go

@@ -30,14 +30,27 @@ func (i ID) Serialize(buf *bytes.Buffer) {
 	buf.Write(convert.Uint32Byte(uint32(i)))
 }
 
+// bitmasks for flags in RouterOptions
+const (
+	RouterOptV6 uint16 = 1 << iota
+	RouterOptE
+	_
+	RouterOptN
+	RouterOptR
+	RouterOptDC
+	_
+	_
+	RouterOptAF
+)
+
 type RouterOptions struct {
-	_        uint16
-	RawFlags uint8
+	_     uint8
+	Flags uint16
 }
 
 func (r *RouterOptions) Serialize(buf *bytes.Buffer) {
-	buf.Write([]byte{0, 0})
-	buf.WriteByte(r.RawFlags)
+	buf.WriteByte(0)
+	buf.Write(convert.Uint16Byte(uint16(r.Flags)))
 }
 
 type LSType uint16

protocols/ospfv3/packet/lsa.go

@@ -332,9 +332,9 @@ func DeserializeInterAreaRouterLSA(buf *bytes.Buffer) (*InterAreaRouterLSA, int,
 
 // Bitmasks for flags used in ASExternalLSA
 const (
-	ASExtLSAFlagE = 4
-	ASExtLSAFlagF = 2
-	ASExtLSAFlagT = 1
+	ASExtLSAFlagT uint8 = 1 << iota
+	ASExtLSAFlagF
+	ASExtLSAFlagE
 )
 
 type ASExternalLSA struct {

protocols/ospfv3/packet/packet.go

@@ -5,14 +5,29 @@ import (
 	"encoding/binary"
 	"fmt"
 
+	"github.com/bio-routing/bio-rd/util/checksum"
 	"github.com/bio-routing/bio-rd/util/decode"
 	"github.com/bio-routing/tflow2/convert"
 	"github.com/pkg/errors"
 )
 
+const expectedVersion = 3
+
+type OSPFMessageType uint8
+
+// OSPF message types
+const (
+	MsgTypeUnknown OSPFMessageType = iota
+	MsgTypeHello
+	MsgTypeDatabaseDescription
+	MsgTypeLinkStateRequest
+	MsgTypeLinkStateUpdate
+	MsgTypeLinkStateAcknowledgment
+)
+
 type OSPFv3Message struct {
 	Version      uint8
-	Type         uint8
+	Type         OSPFMessageType
 	PacketLength uint16
 	RouterID     ID
 	AreaID       ID
@@ -22,21 +37,40 @@ type OSPFv3Message struct {
 }
 
 const OSPFv3MessageHeaderLength = 16
+const OSPFv3MessagePacketLengthAtByte = 2
+const OSPFv3MessageChecksumAtByte = 12
+
+func (x *OSPFv3Message) Serialize(out *bytes.Buffer) {
+	buf := bytes.NewBuffer(nil)
 
-func (x *OSPFv3Message) Serialize(buf *bytes.Buffer) {
 	buf.WriteByte(x.Version)
-	buf.WriteByte(x.Type)
+	buf.WriteByte(uint8(x.Type))
 	buf.Write(convert.Uint16Byte(x.PacketLength))
 	x.RouterID.Serialize(buf)
 	x.AreaID.Serialize(buf)
 	buf.Write(convert.Uint16Byte(x.Checksum))
 	buf.WriteByte(x.InstanceID)
 	buf.WriteByte(0) // 1 byte reserved
 	x.Body.Serialize(buf)
+
+	data := buf.Bytes()
+
+	length := uint16(len(data))
+	putUint16(data, OSPFv3MessagePacketLengthAtByte, length)
+
+	checksum := checksum.IPChecksum(data, OSPFv3MessageChecksumAtByte)
+	putUint16(data, OSPFv3MessageChecksumAtByte, checksum)
+
+	out.Write(data)
+}
+
+func putUint16(b []byte, p int, v uint16) {
+	binary.BigEndian.PutUint16(b[p:p+2], v)
 }
 
 func DeserializeOSPFv3Message(buf *bytes.Buffer) (*OSPFv3Message, int, error) {
 	pdu := &OSPFv3Message{}
+	data := buf.Bytes()
 
 	var readBytes int
 	var err error
@@ -59,6 +93,15 @@ func DeserializeOSPFv3Message(buf *bytes.Buffer) (*OSPFv3Message, int, error) {
 	}
 	readBytes += 16
 
+	if pdu.Version != expectedVersion {
+		return nil, readBytes, fmt.Errorf("Invalid OSPF version: %d", pdu.Version)
+	}
+
+	expectedChecksum := checksum.IPChecksum(data, OSPFv3MessageChecksumAtByte)
+	if pdu.Checksum != expectedChecksum {
+		return nil, readBytes, fmt.Errorf("Checksum mismatch. Expected %#04x, got %#04x", expectedChecksum, pdu.Checksum)
+	}
+
 	n, err := pdu.ReadBody(buf)
 	if err != nil {
 		return nil, readBytes, errors.Wrap(err, "unable to decode message body")
@@ -75,15 +118,15 @@ func (m *OSPFv3Message) ReadBody(buf *bytes.Buffer) (int, error) {
 	var err error
 
 	switch m.Type {
-	case 1:
+	case MsgTypeHello:
 		body, readBytes, err = DeserializeHello(buf, bodyLength)
-	case 2:
+	case MsgTypeDatabaseDescription:
 		body, readBytes, err = DeserializeDatabaseDescription(buf, bodyLength)
-	case 3:
+	case MsgTypeLinkStateRequest:
 		body, readBytes, err = DeserializeLinkStateRequestMsg(buf, bodyLength)
-	case 4:
+	case MsgTypeLinkStateUpdate:
 		body, readBytes, err = DeserializeLinkStateUpdate(buf)
-	case 5:
+	case MsgTypeLinkStateAcknowledgment:
 		body, readBytes, err = DeserializeLinkStateAcknowledgement(buf, bodyLength)
 	default:
 		return 0, fmt.Errorf("unknown message type: %d", m.Type)
@@ -157,10 +200,19 @@ func DeserializeHello(buf *bytes.Buffer, bodyLength uint16) (*Hello, int, error)
 	return pdu, readBytes, nil
 }
 
+type DBFlags uint8
+
+// database description flags
+const (
+	DBFlagInit DBFlags = 1 << iota
+	DBFlagMore
+	DBFlagMS
+)
+
 type DatabaseDescription struct {
 	Options          RouterOptions
 	InterfaceMTU     uint16
-	DBFlags          uint8
+	DBFlags          DBFlags
 	DDSequenceNumber uint32
 	LSAHeaders       []*LSA
 }
@@ -170,7 +222,7 @@ func (x *DatabaseDescription) Serialize(buf *bytes.Buffer) {
 	x.Options.Serialize(buf)
 	buf.Write(convert.Uint16Byte(x.InterfaceMTU))
 	buf.WriteByte(0) // 1 byte reserved
-	buf.WriteByte(x.DBFlags)
+	buf.WriteByte(uint8(x.DBFlags))
 	buf.Write(convert.Uint32Byte(x.DDSequenceNumber))
 	for i := range x.LSAHeaders {
 		x.LSAHeaders[i].Serialize(buf, true)

protocols/ospfv3/server/area.go

@@ -0,0 +1,140 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"sync"
+	"sync/atomic"
+
+	"github.com/bio-routing/bio-rd/protocols/ospfv3/packet"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/vishvananda/netlink"
+)
+
+type AreaConfig struct {
+	ID              packet.ID
+	routerID        packet.ID
+	Stub            bool // in spec ExternalRoutingCapability (changed so default is false)
+	StubDefaultCost packet.InterfaceMetric
+}
+
+type areaManager struct {
+	interfaces      map[string]*interfaceManager
+	interfacesMutex sync.Mutex
+
+	config  AreaConfig
+	started *uint64
+
+	routerLSAs  []packet.RouterLSA
+	networkLSAs []packet.NetworkLSA
+	lsaMutex    sync.Mutex
+
+	tree      spfTree
+	treeMutex sync.Mutex
+
+	rib RoutingTable
+	log logrus.FieldLogger
+}
+
+func newAreaManager(log logrus.FieldLogger, config AreaConfig, rib RoutingTable) (*areaManager, error) {
+	mgmt := &areaManager{
+		interfaces: make(map[string]*interfaceManager),
+
+		config: config,
+		rib:    rib,
+		log:    log.WithField("area", fmt.Sprintf("%d", config.ID)),
+	}
+
+	return mgmt, nil
+}
+
+func (am *areaManager) AddInterface(ctx context.Context, name string, config InterfaceConfig) error {
+	am.interfacesMutex.Lock()
+	defer am.interfacesMutex.Unlock()
+
+	if _, ok := am.interfaces[name]; ok {
+		return errors.New("interface is already configured. cannot reconfigure")
+	}
+
+	ifm, err := newInterfaceManager(am.log.WithField("component", "interfaceManager"), am, name, config)
+	if err != nil {
+		return errors.Wrap(err, "unable to construct interface manager")
+	}
+
+	am.interfaces[name] = ifm
+	if am.Started() {
+		if err := ifm.Start(ctx); err != nil {
+			return errors.Wrap(err, "unable to start interface manager")
+		}
+	}
+
+	return nil
+}
+
+func (am *areaManager) Started() bool {
+	return atomic.LoadUint64(am.started) == 1
+}
+
+func (am *areaManager) Start(ctx context.Context) error {
+	if atomic.SwapUint64(am.started, 1) == 1 {
+		return errors.New("already started")
+	}
+
+	for name, ifm := range am.interfaces {
+		if err := ifm.Start(ctx); err != nil {
+			return errors.Wrap(err, fmt.Sprintf("unable to start interface: %s", name))
+		}
+		intf := ifm.GetInterface()
+		if intf != nil && (intf.Flags&net.FlagUp) != 0 {
+			ifm.SetLinkUp()
+		}
+	}
+
+	if err := am.startMonitorLinks(ctx); err != nil {
+		return errors.Wrap(err, "unable to listen for interface link changes")
+	}
+
+	return nil
+}
+
+func (am *areaManager) GetConfig() AreaConfig {
+	return am.config
+}
+
+func (am *areaManager) startMonitorLinks(ctx context.Context) error {
+	updateCh := make(chan netlink.LinkUpdate)
+	done := make(chan struct{})
+	if err := netlink.LinkSubscribe(updateCh, done); err != nil {
+		return err
+	}
+
+	go func() {
+		for {
+			var update netlink.LinkUpdate
+			select {
+			case <-ctx.Done():
+				close(done)
+				return
+			case update = <-updateCh:
+			}
+
+			name := update.Link.Attrs().Name
+			am.interfacesMutex.Lock()
+			ifm, found := am.interfaces[name]
+			am.interfacesMutex.Unlock()
+			if !found {
+				continue
+			}
+
+			if (net.Flags(update.IfInfomsg.Flags) & net.FlagUp) != 0 {
+				ifm.SetLinkUp()
+			} else {
+				ifm.SetLinkDown()
+			}
+		}
+	}()
+
+	return nil
+}

protocols/ospfv3/server/common.go

@@ -0,0 +1,15 @@
+package server
+
+type Router interface {
+	IsDR() bool
+	IsBDR() bool
+}
+
+// RFC: https://tools.ietf.org/html/rfc2328#page-95 (Section 10.4)
+func shouldFormAdjacency(ifType InterfaceType, self Router, neighbor Router) bool {
+	return ifType == IfTypePointToPoint ||
+		ifType == IfTypePointToMultipoint ||
+		ifType == IfTypeVirtualLink ||
+		self.IsDR() || self.IsBDR() ||
+		neighbor.IsDR() || neighbor.IsBDR()
+}