Merge b49d67c87d into 31ea366e51

internal/lldp/lldp.go

@@ -3,11 +3,12 @@ package lldp
 import (
 	"context"
 	"fmt"
-	"net"
 	"sync"
+	"time"
 
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/afpacket"
+	"github.com/jellydator/ttlcache/v3"
 	"github.com/jetkvm/kvm/internal/logging"
 	"github.com/rs/zerolog"
 )
@@ -29,8 +30,7 @@ type LLDP struct {
 	advertiseOptions *AdvertiseOptions
 	onChange         func(neighbors []Neighbor)
 
-	neighbors   map[neighborCacheKey]Neighbor
-	neighborsMu sync.RWMutex
+	neighbors *ttlcache.Cache[neighborCacheKey, Neighbor]
 
 	// State tracking
 	txRunning bool
@@ -47,8 +47,6 @@ type AdvertiseOptions struct {
 	SysName             string
 	SysDescription      string
 	PortDescription     string
-	IPv4Address         *net.IP
-	IPv6Address         *net.IP
 	SysCapabilities     []string
 	EnabledCapabilities []string
 }
@@ -78,12 +76,14 @@ func NewLLDP(opts *Options) *LLDP {
 		enableTx:         opts.EnableTx,
 		rxWaitGroup:      &sync.WaitGroup{},
 		l:                opts.Logger,
-		neighbors:        make(map[neighborCacheKey]Neighbor),
+		neighbors:        ttlcache.New(ttlcache.WithTTL[neighborCacheKey, Neighbor](1 * time.Hour)),
 		onChange:         opts.OnChange,
 	}
 }
 
 func (l *LLDP) Start() error {
+	go l.neighbors.Start()
+
 	if l.enableRx {
 		if err := l.startRx(); err != nil {
 			return fmt.Errorf("failed to start RX: %w", err)
@@ -102,10 +102,10 @@ func (l *LLDP) Start() error {
 
 // StartRx starts the LLDP receiver if not already running
 func (l *LLDP) startRx() error {
-	l.mu.RLock()
+	l.mu.Lock()
 	running := l.rxRunning
 	enabled := l.enableRx
-	l.mu.RUnlock()
+	l.mu.Unlock()
 
 	if running || !enabled {
 		return nil

internal/lldp/neigh.go

@@ -13,48 +13,26 @@ type ManagementAddress struct {
 }
 
 type Neighbor struct {
-	Mac                 string              `json:"mac"`
-	Source              string              `json:"source"`
-	ChassisID           string              `json:"chassis_id"`
-	PortID              string              `json:"port_id"`
-	PortDescription     string              `json:"port_description"`
-	SystemName          string              `json:"system_name"`
-	SystemDescription   string              `json:"system_description"`
-	TTL                 uint16              `json:"ttl"`
-	ManagementAddresses []ManagementAddress `json:"management_addresses"`
-	Capabilities        []string            `json:"capabilities"`
-	Values              map[string]string   `json:"values"`
-	cacheTTL            time.Time
-	cacheKey            neighborCacheKey
+	Mac               string             `json:"mac"`
+	Source            string             `json:"source"`
+	ChassisID         string             `json:"chassis_id"`
+	PortID            string             `json:"port_id"`
+	PortDescription   string             `json:"port_description"`
+	SystemName        string             `json:"system_name"`
+	SystemDescription string             `json:"system_description"`
+	TTL               uint16             `json:"ttl"`
+	ManagementAddress *ManagementAddress `json:"management_address,omitempty"`
+	Capabilities      []string           `json:"capabilities"`
+	Values            map[string]string  `json:"values"`
 }
 
-const (
-	NeighborSourceLLDP uint8 = 0x1
-	NeighborSourceCDP  uint8 = 0x2
-)
-
-var (
-	NeighborSourceMap = map[uint8]string{
-		NeighborSourceLLDP: "lldp",
-		NeighborSourceCDP:  "cdp",
-	}
-)
-
 type neighborCacheKey struct {
-	Mac    string
-	Source uint8
+	mac    string
+	source string
 }
 
-func newNeighbor(mac string, source uint8) *Neighbor {
-	return &Neighbor{
-		Mac:    mac,
-		Source: NeighborSourceMap[source],
-		Values: make(map[string]string),
-		cacheKey: neighborCacheKey{
-			Mac:    mac,
-			Source: source,
-		},
-	}
+func (n *Neighbor) cacheKey() neighborCacheKey {
+	return neighborCacheKey{mac: n.Mac, source: n.Source}
 }
 
 func (l *LLDP) addNeighbor(neighbor *Neighbor, ttl time.Duration) {
@@ -64,18 +42,19 @@ func (l *LLDP) addNeighbor(neighbor *Neighbor, ttl time.Duration) {
 		Interface("neighbor", neighbor).
 		Logger()
 
-	l.neighborsMu.RLock()
+	key := neighbor.cacheKey()
 
-	_, ok := l.neighbors[neighbor.cacheKey]
-	if ok {
-		logger.Trace().Msg("neighbor already exists, updating it")
+	currentNeighbor := l.neighbors.Get(key)
+	if currentNeighbor != nil {
+		currentSource := currentNeighbor.Value().Source
+		if currentSource == "lldp" && neighbor.Source != "lldp" {
+			logger.Info().Msg("skip updating neighbor, as LLDP has higher priority")
+			return
+		}
 	}
 
 	logger.Trace().Msg("adding neighbor")
-	neighbor.cacheTTL = time.Now().Add(ttl)
-	l.neighbors[neighbor.cacheKey] = *neighbor
-
-	l.neighborsMu.RUnlock()
+	l.neighbors.Set(key, *neighbor, ttl)
 
 	l.onChange(l.GetNeighbors())
 }
@@ -87,33 +66,17 @@ func (l *LLDP) deleteNeighbor(neighbor *Neighbor) {
 		Logger()
 
 	logger.Info().Msg("deleting neighbor")
-
-	l.neighborsMu.Lock()
-	delete(l.neighbors, neighbor.cacheKey)
-	l.neighborsMu.Unlock()
+	l.neighbors.Delete(neighbor.cacheKey())
 
 	l.onChange(l.GetNeighbors())
 }
 
-func (l *LLDP) flushNeighbors() {
-	l.neighborsMu.Lock()
-	defer l.neighborsMu.Unlock()
-
-	l.neighbors = make(map[neighborCacheKey]Neighbor)
-}
-
 func (l *LLDP) GetNeighbors() []Neighbor {
-	l.neighborsMu.Lock()
-	defer l.neighborsMu.Unlock()
+	items := l.neighbors.Items()
+	neighbors := make([]Neighbor, 0, len(items))
 
-	neighbors := make([]Neighbor, 0)
-
-	for key, neighbor := range l.neighbors {
-		if time.Now().After(neighbor.cacheTTL) {
-			delete(l.neighbors, key)
-			continue
-		}
-		neighbors = append(neighbors, neighbor)
+	for _, item := range items {
+		neighbors = append(neighbors, item.Value())
 	}
 
 	return neighbors

internal/lldp/rx.go

@@ -88,11 +88,6 @@ func (l *LLDP) setUpCapture() error {
 }
 
 func (l *LLDP) doCapture(logger *zerolog.Logger) {
-	if l.pktSourceRx == nil || l.rxCtx == nil {
-		logger.Error().Msg("packet source or RX context not initialized")
-		return
-	}
-
 	l.rxWaitGroup.Add(1)
 	defer l.rxWaitGroup.Done()
 
@@ -242,7 +237,11 @@ func capabilitiesToString(capabilities layers.LLDPCapabilities) []string {
 }
 
 func (l *LLDP) handlePacketLLDP(mac string, raw *layers.LinkLayerDiscovery, info *layers.LinkLayerDiscoveryInfo) error {
-	n := newNeighbor(mac, NeighborSourceLLDP)
+	n := &Neighbor{
+		Values: make(map[string]string),
+		Source: "lldp",
+		Mac:    mac,
+	}
 
 	ttl := lldpDefaultTTL
 
@@ -264,12 +263,12 @@ func (l *LLDP) handlePacketLLDP(mac string, raw *layers.LinkLayerDiscovery, info
 			n.SystemDescription = info.SysDescription
 			n.Values["system_description"] = n.SystemDescription
 		case layers.LLDPTLVMgmtAddress:
-			mgmtAddress := parseTlvMgmtAddress(v)
-			if mgmtAddress != nil {
-				n.ManagementAddresses = append(
-					n.ManagementAddresses,
-					lldpMgmtAddressToSerializable(mgmtAddress),
-				)
+			n.ManagementAddress = &ManagementAddress{
+				AddressFamily:    info.MgmtAddress.Subtype.String(),
+				Address:          net.IP(info.MgmtAddress.Address).String(),
+				InterfaceSubtype: info.MgmtAddress.InterfaceSubtype.String(),
+				InterfaceNumber:  info.MgmtAddress.InterfaceNumber,
+				OID:              info.MgmtAddress.OID,
 			}
 		case layers.LLDPTLVSysCapabilities:
 			n.Capabilities = capabilitiesToString(info.SysCapabilities.EnabledCap)
@@ -298,7 +297,11 @@ func (l *LLDP) handlePacketLLDP(mac string, raw *layers.LinkLayerDiscovery, info
 
 func (l *LLDP) handlePacketCDP(mac string, raw *layers.CiscoDiscovery, info *layers.CiscoDiscoveryInfo) error {
 	// TODO: implement full CDP parsing
-	n := newNeighbor(mac, NeighborSourceCDP)
+	n := &Neighbor{
+		Values: make(map[string]string),
+		Source: "cdp",
+		Mac:    mac,
+	}
 
 	ttl := cdpDefaultTTL
 
@@ -312,18 +315,27 @@ func (l *LLDP) handlePacketCDP(mac string, raw *layers.CiscoDiscovery, info *lay
 		ttl = time.Duration(n.TTL) * time.Second
 	}
 
-	for _, addr := range info.MgmtAddresses {
-		addrFamily := "ipv4"
-		if addr.To4() == nil {
-			addrFamily = "ipv6"
+	if len(info.MgmtAddresses) > 0 {
+		ip := info.MgmtAddresses[0]
+		ipFamily := "ipv4"
+		if ip.To4() == nil {
+			ipFamily = "ipv6"
 		}
-		n.ManagementAddresses = append(n.ManagementAddresses, ManagementAddress{
-			AddressFamily:    addrFamily,
-			Address:          addr.String(),
+
+		l.l.Info().
+			Str("ip", ip.String()).
+			Str("ip_family", ipFamily).
+			Interface("ip", ip).
+			Interface("info", info).
+			Msg("parsed IP address")
+
+		n.ManagementAddress = &ManagementAddress{
+			AddressFamily:    ipFamily,
+			Address:          ip.String(),
 			InterfaceSubtype: "if_name",
 			InterfaceNumber:  0,
 			OID:              "",
-		})
+		}
 	}
 
 	l.addNeighbor(n, ttl)
@@ -360,7 +372,7 @@ func (l *LLDP) stopCapture() error {
 		// write an empty packet to the TPacketRx to interrupt the blocking read
 		// it's a shitty workaround until https://github.com/google/gopacket/pull/777 is merged,
 		// or we have a better solution, see https://github.com/google/gopacket/issues/1064
-		_ = l.tPacketRx.WritePacketData([]byte{})
+		l.tPacketRx.WritePacketData([]byte{})
 	}()
 
 	// wait for the goroutine to finish
@@ -390,7 +402,7 @@ func (l *LLDP) stopRx() error {
 	}
 
 	// clean up the neighbors table
-	l.flushNeighbors()
+	l.neighbors.DeleteAll()
 	l.onChange([]Neighbor{})
 
 	return nil

internal/lldp/tlv.go

@@ -1,131 +0,0 @@
-package lldp
-
-import (
-	"encoding/binary"
-	"fmt"
-	"net"
-
-	"github.com/google/gopacket/layers"
-)
-
-var (
-	capabilityMap = map[string]uint16{
-		"other":        layers.LLDPCapsOther,
-		"repeater":     layers.LLDPCapsRepeater,
-		"bridge":       layers.LLDPCapsBridge,
-		"wlanap":       layers.LLDPCapsWLANAP,
-		"router":       layers.LLDPCapsRouter,
-		"phone":        layers.LLDPCapsPhone,
-		"docsis":       layers.LLDPCapsDocSis,
-		"station_only": layers.LLDPCapsStationOnly,
-		"cvlan":        layers.LLDPCapsCVLAN,
-		"svlan":        layers.LLDPCapsSVLAN,
-		"tmpr":         layers.LLDPCapsTmpr,
-	}
-)
-
-func tlvMgmtAddressToBytes(m *layers.LLDPMgmtAddress) []byte {
-	var b []byte
-	b = append(b, byte(len(m.Address))+1)   // TLV Length
-	b = append(b, byte(m.Subtype))          // Address Subtype
-	b = append(b, m.Address...)             // Address
-	b = append(b, byte(m.InterfaceSubtype)) // Interface Subtype
-
-	ifIndex := make([]byte, 4) // 4 bytes for the interface number
-	binary.BigEndian.PutUint32(ifIndex, m.InterfaceNumber)
-	b = append(b, ifIndex...)
-
-	b = append(b, 0) // OID type
-	return b
-}
-
-func tlvMgmtAddress(m *layers.LLDPMgmtAddress) layers.LinkLayerDiscoveryValue {
-	return layers.LinkLayerDiscoveryValue{
-		Type:   layers.LLDPTLVMgmtAddress,
-		Value:  tlvMgmtAddressToBytes(m),
-		Length: uint16(len(tlvMgmtAddressToBytes(m))),
-	}
-}
-
-// if err := checkLLDPTLVLen(v, 9); err != nil {
-// 	return err
-// }
-// mlen := v.Value[0]
-// if err := checkLLDPTLVLen(v, int(mlen+7)); err != nil {
-// 	return err
-// }
-// info.MgmtAddress.Subtype = IANAAddressFamily(v.Value[1])
-// info.MgmtAddress.Address = v.Value[2 : mlen+1]
-// info.MgmtAddress.InterfaceSubtype = LLDPInterfaceSubtype(v.Value[mlen+1])
-// info.MgmtAddress.InterfaceNumber = binary.BigEndian.Uint32(v.Value[mlen+2 : mlen+6])
-// olen := v.Value[mlen+6]
-// if err := checkLLDPTLVLen(v, int(mlen+7+olen)); err != nil {
-// 	return err
-// }
-// info.MgmtAddress.OID = string(v.Value[mlen+7 : mlen+7+olen])
-
-func checkLLDPTLVLen(v layers.LinkLayerDiscoveryValue, l int) (err error) {
-	if len(v.Value) < l {
-		err = fmt.Errorf("invalid TLV %v length %d (wanted minimum %d)", v.Type, len(v.Value), l)
-	}
-	return
-}
-
-// parseTlvMgmtAddress parses the Management Address TLV and returns the Management Address
-// structure.
-// we don't parse the OID here, as it's not needed for the neighbor cache
-func parseTlvMgmtAddress(v layers.LinkLayerDiscoveryValue) *layers.LLDPMgmtAddress {
-	if err := checkLLDPTLVLen(v, 9); err != nil {
-		return nil
-	}
-
-	mlen := v.Value[0]
-	if err := checkLLDPTLVLen(v, int(mlen+7)); err != nil {
-		return nil
-	}
-
-	return &layers.LLDPMgmtAddress{
-		Subtype:          layers.IANAAddressFamily(v.Value[1]),
-		Address:          v.Value[2 : mlen+1],
-		InterfaceSubtype: layers.LLDPInterfaceSubtype(v.Value[mlen+1]),
-		InterfaceNumber:  binary.BigEndian.Uint32(v.Value[mlen+2 : mlen+6]),
-	}
-}
-
-func lldpMgmtAddressToSerializable(m *layers.LLDPMgmtAddress) ManagementAddress {
-	var addrString string
-	switch m.Subtype {
-	case layers.IANAAddressFamilyIPV4:
-		addrString = net.IP(m.Address).String()
-	case layers.IANAAddressFamilyIPV6:
-		addrString = net.IP(m.Address).String()
-	default:
-		addrString = string(m.Address)
-	}
-
-	return ManagementAddress{
-		AddressFamily:    m.Subtype.String(),
-		Address:          addrString,
-		InterfaceSubtype: m.InterfaceSubtype.String(),
-		InterfaceNumber:  m.InterfaceNumber,
-	}
-}
-
-func tlvStringValue(tlvType layers.LLDPTLVType, value string) layers.LinkLayerDiscoveryValue {
-	return layers.LinkLayerDiscoveryValue{
-		Type:   tlvType,
-		Value:  []byte(value),
-		Length: uint16(len(value)),
-	}
-}
-
-func toLLDPCapabilitiesBytes(capabilities []string) uint16 {
-	r := uint16(0)
-	for _, capability := range capabilities {
-		mask, ok := capabilityMap[capability]
-		if ok {
-			r |= mask
-		}
-	}
-	return r
-}

internal/lldp/tx.go

@@ -17,6 +17,57 @@ var (
 	lldpEtherType = layers.EthernetTypeLinkLayerDiscovery
 )
 
+// func encodeMandatoryTLV(subType byte, id []byte) []byte {
+// 	// 1 byte: subtype
+// 	// N bytes: ID
+// 	b := make([]byte, 1+len(id))
+// 	b[0] = byte(subtype)
+// 	copy(b[1:], id)
+
+// 	return b
+// }
+
+// func (l *LLDP) createLLDPPayload() ([]byte, error) {
+// 	tlv := &layers.LinkLayerDiscoveryValue{
+// 		Type:  layers.LLDPTLVChassisID,
+
+// }
+
+func tlvStringValue(tlvType layers.LLDPTLVType, value string) layers.LinkLayerDiscoveryValue {
+	return layers.LinkLayerDiscoveryValue{
+		Type:   tlvType,
+		Value:  []byte(value),
+		Length: uint16(len(value)),
+	}
+}
+
+var (
+	capabilityMap = map[string]uint16{
+		"other":        layers.LLDPCapsOther,
+		"repeater":     layers.LLDPCapsRepeater,
+		"bridge":       layers.LLDPCapsBridge,
+		"wlanap":       layers.LLDPCapsWLANAP,
+		"router":       layers.LLDPCapsRouter,
+		"phone":        layers.LLDPCapsPhone,
+		"docsis":       layers.LLDPCapsDocSis,
+		"station_only": layers.LLDPCapsStationOnly,
+		"cvlan":        layers.LLDPCapsCVLAN,
+		"svlan":        layers.LLDPCapsSVLAN,
+		"tmpr":         layers.LLDPCapsTmpr,
+	}
+)
+
+func toLLDPCapabilitiesBytes(capabilities []string) uint16 {
+	r := uint16(0)
+	for _, capability := range capabilities {
+		mask, ok := capabilityMap[capability]
+		if ok {
+			r |= mask
+		}
+	}
+	return r
+}
+
 func (l *LLDP) toPayloadValues() []layers.LinkLayerDiscoveryValue {
 	// See also: layers.LinkLayerDiscovery.SerializeTo()
 	r := []layers.LinkLayerDiscoveryValue{}
@@ -37,24 +88,6 @@ func (l *LLDP) toPayloadValues() []layers.LinkLayerDiscoveryValue {
 		r = append(r, tlvStringValue(layers.LLDPTLVSysDescription, opts.SysDescription))
 	}
 
-	if opts.IPv4Address != nil {
-		r = append(r, tlvMgmtAddress(&layers.LLDPMgmtAddress{
-			Subtype:          layers.IANAAddressFamilyIPV4,
-			Address:          opts.IPv4Address.To4(),
-			InterfaceSubtype: layers.LLDPInterfaceSubtypeifIndex,
-			InterfaceNumber:  0,
-		}))
-	}
-
-	if opts.IPv6Address != nil {
-		r = append(r, tlvMgmtAddress(&layers.LLDPMgmtAddress{
-			Subtype:          layers.IANAAddressFamilyIPV6,
-			Address:          opts.IPv6Address.To16(),
-			InterfaceSubtype: layers.LLDPInterfaceSubtypeifIndex,
-			InterfaceNumber:  0,
-		}))
-	}
-
 	if len(opts.SysCapabilities) > 0 {
 		value := make([]byte, 4)
 		binary.BigEndian.PutUint16(value[0:2], toLLDPCapabilitiesBytes(opts.SysCapabilities))
@@ -194,9 +227,7 @@ func (l *LLDP) startTx() error {
 		cancel()
 	}
 
-	l.mu.Lock()
 	l.txCtx, l.txCancel = context.WithCancel(context.Background())
-	l.mu.Unlock()
 
 	if err := l.setUpTx(); err != nil {
 		return fmt.Errorf("failed to set up TX: %w", err)

network.go

@@ -3,7 +3,6 @@ package kvm
 import (
 	"context"
 	"fmt"
-	"net"
 	"reflect"
 
 	"github.com/jetkvm/kvm/internal/confparser"
@@ -120,11 +119,6 @@ func networkStateChanged(_ string, state types.InterfaceState) {
 		triggerTimeSyncOnNetworkStateChange()
 	}
 
-	// update the LLDP advertise options
-	if lldpService != nil {
-		_ = lldpService.SetAdvertiseOptions(getLLDPAdvertiseOptions(&state))
-	}
-
 	// always restart mDNS when the network state changes
 	if mDNS != nil {
 		restartMdns()
@@ -150,29 +144,13 @@ func validateNetworkConfig() {
 	}
 }
 
-func getLLDPAdvertiseOptions(state *types.InterfaceState) *lldp.AdvertiseOptions {
-	a := &lldp.AdvertiseOptions{
+func getLLDPAdvertiseOptions(nm *nmlite.NetworkManager) *lldp.AdvertiseOptions {
+	return &lldp.AdvertiseOptions{
+		SysName:             nm.Hostname(),
 		SysDescription:      toLLDPSysDescription(),
 		SysCapabilities:     []string{"other", "router", "wlanap"},
 		EnabledCapabilities: []string{"other"},
 	}
-	if state == nil {
-		return a
-	}
-
-	a.SysName = state.Hostname
-	ip4String := state.IPv4Address
-	if ip4String != "" {
-		ip4 := net.ParseIP(ip4String)
-		a.IPv4Address = &ip4
-	}
-	ip6String := state.IPv6Address
-	if ip6String != "" {
-		ip6 := net.ParseIP(ip6String)
-		a.IPv6Address = &ip6
-	}
-	networkLogger.Info().Interface("advertiseOptions", a).Msg("LLDP advertise options")
-	return a
 }
 
 func initNetwork() error {
@@ -194,12 +172,7 @@ func initNetwork() error {
 
 	networkManager = nm
 
-	ifState, err := nm.GetInterfaceState(NetIfName)
-	if err != nil {
-		networkLogger.Warn().Err(err).Msg("failed to get interface state, LLDP will use the default options")
-	}
-
-	advertiseOptions := getLLDPAdvertiseOptions(ifState)
+	advertiseOptions := getLLDPAdvertiseOptions(nm)
 	lldpService = lldp.NewLLDP(&lldp.Options{
 		InterfaceName:    NetIfName,
 		EnableRx:         nc.ShouldEnableLLDPReceive(),
@@ -227,7 +200,7 @@ func toLLDPSysDescription() string {
 	return fmt.Sprintf("JetKVM (app: %s, system: %s)", appVersion.String(), systemVersion.String())
 }
 
-func updateLLDPOptions(nc *types.NetworkConfig, ifState *types.InterfaceState) {
+func updateLLDPOptions(nc *types.NetworkConfig) {
 	if lldpService == nil {
 		return
 	}
@@ -236,16 +209,7 @@ func updateLLDPOptions(nc *types.NetworkConfig, ifState *types.InterfaceState) {
 		networkLogger.Error().Err(err).Msg("failed to set LLDP RX and TX")
 	}
 
-	if ifState == nil {
-		newIfState, err := networkManager.GetInterfaceState(NetIfName)
-		if err != nil {
-			networkLogger.Warn().Err(err).Msg("failed to get interface state, LLDP will use the default options")
-			return
-		}
-		ifState = newIfState
-	}
-
-	advertiseOptions := getLLDPAdvertiseOptions(ifState)
+	advertiseOptions := getLLDPAdvertiseOptions(networkManager)
 	if err := lldpService.SetAdvertiseOptions(advertiseOptions); err != nil {
 		networkLogger.Error().Err(err).Msg("failed to set LLDP advertise options")
 	}
@@ -379,7 +343,7 @@ func rpcSetNetworkSettings(settings RpcNetworkSettings) (*RpcNetworkSettings, er
 	config.NetworkConfig = newConfig
 
 	// update the LLDP advertise options
-	updateLLDPOptions(newConfig, nil)
+	updateLLDPOptions(newConfig)
 
 	l.Debug().Msg("saving new config")
 	if err := SaveConfig(); err != nil {

ui/src/components/LLDPNeighborsCard.tsx

@@ -37,8 +37,7 @@ export default function LLDPNeighborsCard({
           <div className="space-y-3 pt-2">
             {neighbors.map(neighbor => {
               const displayName = neighbor.system_name || neighbor.port_description || neighbor.mac;
-              const key = `${neighbor.mac}-${neighbor.source}`;
-              return <div className="space-y-3" key={key}>
+              return <div className="space-y-3" key={neighbor.mac}>
                 <h4 className="text-sm font-semibold font-mono">{displayName}</h4>
                 <div
                   className="rounded-md rounded-l-none border border-slate-500/10 border-l-blue-700/50 bg-white p-4 pl-4 backdrop-blur-sm dark:bg-transparent"
@@ -65,10 +64,8 @@ export default function LLDPNeighborsCard({
                       <LLDPDataLine label="Port Description" value={neighbor.port_description} />
                     )}
 
-                    {neighbor.management_addresses && neighbor.management_addresses.length > 0 && (
-                      neighbor.management_addresses.map((address, index) => (
-                        <LLDPDataLine label="Management Address" value={address.address} key={index} />
-                      ))
+                    {neighbor.management_address && (
+                      <LLDPDataLine label="Management Address" value={neighbor.management_address.address} />
                     )}
 
                     {neighbor.mac && (

ui/src/hooks/stores.ts

@@ -824,7 +824,7 @@ export interface LLDPNeighbor {
   system_description: string;
   capabilities: string[];
   ttl: number | null;
-  management_addresses: LLDPManagementAddress[];
+  management_address: LLDPManagementAddress | null;
   values: Record<string, string>;
 }
 

ui/src/routes/devices.$id.settings.network.tsx

@@ -169,10 +169,7 @@ export default function SettingsNetworkRoute() {
 
   const { register, handleSubmit, watch, formState, reset } = formMethods;
 
-  const [isSubmitting, setIsSubmitting] = useState(false);
-
   const onSubmit = useCallback(async (settings: NetworkSettings) => {
-
     if (settings.ipv4_static?.address?.includes("/")) {
       const parts = settings.ipv4_static.address.split("/");
       const cidrNotation = Number.parseInt(parts[1]);
@@ -183,7 +180,6 @@ export default function SettingsNetworkRoute() {
       settings.ipv4_static.address = parts[0];
     }
 
-    setIsSubmitting(true);
     send("setNetworkSettings", { settings }, async (resp) => {
       if ("error" in resp) {
         notifications.error(m.network_save_settings_failed({ error: resp.error.message || m.unknown_error() }));
@@ -201,10 +197,10 @@ export default function SettingsNetworkRoute() {
         } catch (error) {
           console.error("Failed to fetch network data:", error);
         }
-        setIsSubmitting(false);
+        notifications.success(m.network_dhcp_lease_renew_success());
       }
     });
-  }, [fetchNetworkData, reset, send, setIsSubmitting]);
+  }, [fetchNetworkData, reset, send]);
 
   const onSubmitGate = useCallback(async (data: FieldValues) => {
     const settings = prepareSettings(data);
@@ -330,7 +326,7 @@ export default function SettingsNetworkRoute() {
                   size="SM"
                   theme="primary"
                   disabled={!(formState.isDirty || formState.isSubmitting)}
-                  loading={formState.isSubmitting || isSubmitting}
+                  loading={formState.isSubmitting}
                   type="submit"
                   text={formState.isSubmitting ? m.saving() : m.network_save_settings()}
                 />