main.go

@@ -50,7 +50,6 @@ const routingTableTemplate = `
 	<thead><tr>
 		<th>Network range</th>
 		<th>Extended?</th>
-		<th>Zone names</th>
 		<th>Distance</th>
 		<th>Last seen</th>
 		<th>Port</th>
@@ -59,8 +58,7 @@ const routingTableTemplate = `
 {{range $route := . }}
 	<tr>
 		<td>{{$route.NetStart}}{{if not (eq $route.NetStart $route.NetEnd)}} - {{$route.NetEnd}}{{end}}</td>
-		<td>{{if $route.Extended}}✅{{else}}-{{end}}</td>
+		<td>{{if $route.Extended}}✅{{else}}❌{{end}}</td>
-		<td>{{range $route.ZoneNames.ToSlice}}{{.}}<br>{{end}}</td>
 		<td>{{$route.Distance}}</td>
 		<td>{{$route.LastSeenAgo}}</td>
 		<td>
@@ -80,6 +78,27 @@ const routingTableTemplate = `
 </table>
 `
 
+const zoneTableTemplate = `
+<table>
+	<thead><tr>
+		<th>Network</th>
+		<th>Name</th>
+		<th>Local Port</th>
+		<th>Last seen</th>
+	</tr></thead>
+	<tbody>
+{{range $zone := . }}
+	<tr>
+		<td>{{$zone.Network}}</td>
+		<td>{{$zone.Name}}</td>
+		<td>{{with $zone.LocalPort}}{{.Device}}{{else}}-{{end}}</td>
+		<td>{{$zone.LastSeenAgo}}</td>
+	</tr>
+{{end}}
+	</tbody>
+</table>
+`
+
 const peerTableTemplate = `
 <table>
 	<thead><tr>
@@ -201,6 +220,15 @@ func main() {
 		return rs, nil
 	})
 
+	zones := router.NewZoneTable()
+	status.AddItem(ctx, "Zone table", zoneTableTemplate, func(context.Context) (any, error) {
+		zs := zones.Dump()
+		slices.SortFunc(zs, func(za, zb router.Zone) int {
+			return cmp.Compare(za.Name, zb.Name)
+		})
+		return zs, nil
+	})
+
 	// -------------------------------- Peers ---------------------------------
 	var peersMu sync.Mutex
 	peers := make(map[udpAddr]*router.AURPPeer)
@@ -288,6 +316,7 @@ func main() {
 		}
 
 		peer := &router.AURPPeer{
+			Config: cfg,
 			Transport: &aurp.Transport{
 				LocalDI:     localDI,
 				RemoteDI:    aurp.IPDomainIdentifier(raddr.IP),
@@ -297,7 +326,8 @@ func main() {
 			ConfiguredAddr: peerStr,
 			RemoteAddr:     raddr,
 			ReceiveCh:      make(chan aurp.Packet, 1024),
-			RouteTable:     routes,
+			RoutingTable:   routes,
+			ZoneTable:      zones,
 		}
 		aurp.Inc(&nextConnID)
 		peersMu.Lock()
@@ -314,7 +344,7 @@ func main() {
 	rooter := &router.Router{
 		Config:     cfg,
 		RouteTable: routes,
-		// ZoneTable:  zones,
+		ZoneTable:  zones,
 	}
 
 	etherTalkPort := &router.EtherTalkPort{
@@ -323,13 +353,16 @@ func main() {
 		NetStart:        cfg.EtherTalk.NetStart,
 		NetEnd:          cfg.EtherTalk.NetEnd,
 		DefaultZoneName: cfg.EtherTalk.ZoneName,
-		AvailableZones:  router.SetFromSlice([]string{cfg.EtherTalk.ZoneName}),
+		AvailableZones:  []string{cfg.EtherTalk.ZoneName},
 		PcapHandle:      pcapHandle,
 		AARPMachine:     aarpMachine,
 		Router:          rooter,
 	}
 	rooter.Ports = append(rooter.Ports, etherTalkPort)
 	routes.InsertEtherTalkDirect(etherTalkPort)
+	for _, az := range etherTalkPort.AvailableZones {
+		zones.Upsert(etherTalkPort.NetStart, az, etherTalkPort)
+	}
 
 	// --------------------------------- RTMP ---------------------------------
 	go etherTalkPort.RunRTMP(ctx)
@@ -395,15 +428,17 @@ func main() {
 				}
 				// New peer!
 				pr = &router.AURPPeer{
+					Config: cfg,
 					Transport: &aurp.Transport{
 						LocalDI:     localDI,
 						RemoteDI:    dh.SourceDI, // platinum rule
 						LocalConnID: nextConnID,
 					},
-					UDPConn:    ln,
+					UDPConn:      ln,
-					RemoteAddr: raddr,
+					RemoteAddr:   raddr,
-					ReceiveCh:  make(chan aurp.Packet, 1024),
+					ReceiveCh:    make(chan aurp.Packet, 1024),
-					RouteTable: routes,
+					RoutingTable: routes,
+					ZoneTable:    zones,
 				}
 				aurp.Inc(&nextConnID)
 				peers[ra] = pr

router/misc.go

@@ -1,52 +0,0 @@
-/*
-   Copyright 2024 Josh Deprez
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-package router
-
-// StringSet is a set of strings.
-// Yep, yet another string set implementation. Took me 2 minutes to write *shrug*
-type StringSet map[string]struct{}
-
-func (set StringSet) ToSlice() []string {
-	ss := make([]string, 0, len(set))
-	for s := range set {
-		ss = append(ss, s)
-	}
-	return ss
-}
-
-func (set StringSet) Contains(s string) bool {
-	_, c := set[s]
-	return c
-}
-
-func (set StringSet) Insert(ss ...string) {
-	for _, s := range ss {
-		set[s] = struct{}{}
-	}
-}
-
-func (set StringSet) Add(t StringSet) {
-	for s := range t {
-		set[s] = struct{}{}
-	}
-}
-
-func SetFromSlice(ss []string) StringSet {
-	set := make(StringSet, len(ss))
-	set.Insert(ss...)
-	return set
-}

router/nbp.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"slices"
 
 	"gitea.drjosh.dev/josh/jrouter/atalk"
 	"gitea.drjosh.dev/josh/jrouter/atalk/nbp"
@@ -73,10 +74,10 @@ func (port *EtherTalkPort) handleNBPBrRq(ctx context.Context, ddpkt *ddp.ExtPack
 	// 	tuple.Zone = port.DefaultZoneName
 	// }
 
-	routes := port.Router.RouteTable.RoutesForZone(tuple.Zone)
+	zones := port.Router.ZoneTable.LookupName(tuple.Zone)
 
-	for _, route := range routes {
+	for _, z := range zones {
-		if outPort := route.EtherTalkDirect; outPort != nil {
+		if outPort := z.LocalPort; outPort != nil {
 			// If it's for a local zone, translate it to a LkUp and broadcast
 			// out the corresponding EtherTalk port.
 			// "Note: On an internet, nodes on extended networks performing lookups in
@@ -146,7 +147,7 @@ func (port *EtherTalkPort) handleNBPBrRq(ctx context.Context, ddpkt *ddp.ExtPack
 				SrcNet:    ddpkt.SrcNet,
 				SrcNode:   ddpkt.SrcNode,
 				SrcSocket: ddpkt.SrcSocket,
-				DstNet:    route.NetStart,
+				DstNet:    z.Network,
 				DstNode:   0x00, // Any router for the dest network
 				DstSocket: 2,
 				Proto:     ddp.ProtoNBP,
@@ -169,7 +170,7 @@ func (rtr *Router) handleNBPFwdReq(ctx context.Context, ddpkt *ddp.ExtPacket, nb
 	tuple := &nbpkt.Tuples[0]
 
 	for _, outPort := range rtr.Ports {
-		if !outPort.AvailableZones.Contains(tuple.Zone) {
+		if !slices.Contains(outPort.AvailableZones, tuple.Zone) {
 			continue
 		}
 		log.Printf("NBP: Converting FwdReq to LkUp (%v)", tuple)

router/peer_aurp.go

@@ -94,6 +94,9 @@ func (ss SenderState) String() string {
 
 // AURPPeer handles the peering with a peer AURP router.
 type AURPPeer struct {
+	// Whole router config.
+	Config *Config
+
 	// AURP-Tr state for producing packets.
 	Transport *aurp.Transport
 
@@ -111,8 +114,11 @@ type AURPPeer struct {
 	// Incoming packet channel.
 	ReceiveCh chan aurp.Packet
 
-	// Route table (the peer will add/remove/update routes and zones)
+	// Routing table (the peer will add/remove/update routes)
-	RouteTable *RouteTable
+	RoutingTable *RouteTable
+
+	// Zone table (the peer will add/remove/update zones)
+	ZoneTable *ZoneTable
 
 	mu     sync.RWMutex
 	rstate ReceiverState
@@ -247,7 +253,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 				if sendRetries >= tickleRetryLimit {
 					log.Printf("AURP Peer: Send retry limit reached while waiting for Tickle-Ack, closing connection")
 					p.setRState(ReceiverUnconnected)
-					p.RouteTable.DeleteAURPPeer(p)
+					p.RoutingTable.DeleteAURPPeer(p)
 					break
 				}
 
@@ -266,7 +272,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 				if sendRetries >= sendRetryLimit {
 					log.Printf("AURP Peer: Send retry limit reached while waiting for RI-Rsp, closing connection")
 					p.setRState(ReceiverUnconnected)
-					p.RouteTable.DeleteAURPPeer(p)
+					p.RoutingTable.DeleteAURPPeer(p)
 					break
 				}
 
@@ -437,17 +443,15 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 					log.Printf("AURP Peer: Received RI-Req but was not expecting one (sender state was %v)", p.sstate)
 				}
 
-				var nets aurp.NetworkTuples
+				nets := aurp.NetworkTuples{
-				for _, r := range p.RouteTable.ValidNonAURPRoutes() {
+					{
-					nets = append(nets, aurp.NetworkTuple{
+						Extended:   true,
-						Extended:   r.Extended,
+						RangeStart: p.Config.EtherTalk.NetStart,
-						RangeStart: r.NetStart,
+						RangeEnd:   p.Config.EtherTalk.NetEnd,
-						RangeEnd:   r.NetEnd,
+						Distance:   0,
-						Distance:   r.Distance,
+					},
-					})
 				}
 				p.Transport.LocalSeq = 1
-				// TODO: Split tuples across multiple packets as required
 				lastRISent = p.Transport.NewRIRspPacket(aurp.RoutingFlagLast, nets)
 				if _, err := p.Send(lastRISent); err != nil {
 					log.Printf("AURP Peer: Couldn't send RI-Rsp packet: %v", err)
@@ -463,7 +467,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 				log.Printf("AURP Peer: Learned about these networks: %v", pkt.Networks)
 
 				for _, nt := range pkt.Networks {
-					p.RouteTable.InsertAURPRoute(
+					p.RoutingTable.InsertAURPRoute(
 						p,
 						nt.Extended,
 						ddp.Network(nt.RangeStart),
@@ -503,28 +507,11 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 				sendRetries = 0
 
 				// If SZI flag is set, send ZI-Rsp (transaction)
+				// TODO: split ZI-Rsp packets similarly to ZIP Replies
 				if pkt.Flags&aurp.RoutingFlagSendZoneInfo != 0 {
-					// Inspect last routing info packet sent to determine
+					zones := map[ddp.Network][]string{
-					// networks to gather names for
+						p.Config.EtherTalk.NetStart: {p.Config.EtherTalk.ZoneName},
-					var nets []ddp.Network
-					switch last := lastRISent.(type) {
-					case *aurp.RIRspPacket:
-						for _, nt := range last.Networks {
-							nets = append(nets, nt.RangeStart)
-						}
-
-					case *aurp.RIUpdPacket:
-						for _, et := range last.Events {
-							// Only networks that were added
-							if et.EventCode != aurp.EventCodeNA {
-								continue
-							}
-							nets = append(nets, et.RangeStart)
-						}
-
 					}
-					zones := p.RouteTable.ZonesForNetworks(nets)
-					// TODO: split ZI-Rsp packets similarly to ZIP Replies
 					if _, err := p.Send(p.Transport.NewZIRspPacket(zones)); err != nil {
 						log.Printf("AURP Peer: Couldn't send ZI-Rsp packet: %v", err)
 					}
@@ -556,7 +543,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 						// Do nothing except respond with RI-Ack
 
 					case aurp.EventCodeNA:
-						if err := p.RouteTable.InsertAURPRoute(
+						if err := p.RoutingTable.InsertAURPRoute(
 							p,
 							et.Extended,
 							et.RangeStart,
@@ -568,10 +555,10 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 						ackFlag = aurp.RoutingFlagSendZoneInfo
 
 					case aurp.EventCodeND:
-						p.RouteTable.DeleteAURPPeerNetwork(p, et.RangeStart)
+						p.RoutingTable.DeleteAURPPeerNetwork(p, et.RangeStart)
 
 					case aurp.EventCodeNDC:
-						p.RouteTable.UpdateAURPRouteDistance(p, et.RangeStart, et.Distance+1)
+						p.RoutingTable.UpdateAURPRouteDistance(p, et.RangeStart, et.Distance+1)
 
 					case aurp.EventCodeNRC:
 						// "An exterior router sends a Network Route Change
@@ -579,7 +566,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 						// through its local internet changes to a path through
 						// a tunneling port, causing split-horizoned processing
 						// to eliminate that network’s routing information."
-						p.RouteTable.DeleteAURPPeerNetwork(p, et.RangeStart)
+						p.RoutingTable.DeleteAURPPeerNetwork(p, et.RangeStart)
 
 					case aurp.EventCodeZC:
 						// "This event is reserved for future use."
@@ -597,7 +584,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 				}
 
 				log.Printf("AURP Peer: Router Down: error code %d %s", pkt.ErrorCode, pkt.ErrorCode)
-				p.RouteTable.DeleteAURPPeer(p)
+				p.RoutingTable.DeleteAURPPeer(p)
 
 				// Respond with RI-Ack
 				if _, err := p.Send(p.Transport.NewRIAckPacket(pkt.ConnectionID, pkt.Sequence, 0)); err != nil {
@@ -609,7 +596,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 
 			case *aurp.ZIReqPacket:
 				// TODO: split ZI-Rsp packets similarly to ZIP Replies
-				zones := p.RouteTable.ZonesForNetworks(pkt.Networks)
+				zones := p.ZoneTable.Query(pkt.Networks)
 				if _, err := p.Send(p.Transport.NewZIRspPacket(zones)); err != nil {
 					log.Printf("AURP Peer: Couldn't send ZI-Rsp packet: %v", err)
 					return err
@@ -618,7 +605,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
 			case *aurp.ZIRspPacket:
 				log.Printf("AURP Peer: Learned about these zones: %v", pkt.Zones)
 				for _, zt := range pkt.Zones {
-					p.RouteTable.AddZonesToNetwork(zt.Network, zt.Name)
+					p.ZoneTable.Upsert(ddp.Network(zt.Network), zt.Name, nil)
 				}
 
 			case *aurp.GDZLReqPacket:

router/port.go

@@ -37,7 +37,7 @@ type EtherTalkPort struct {
 	NetEnd          ddp.Network
 	MyAddr          ddp.Addr
 	DefaultZoneName string
-	AvailableZones  StringSet
+	AvailableZones  []string
 	PcapHandle      *pcap.Handle
 	AARPMachine     *AARPMachine
 	Router          *Router

router/route.go

@@ -34,10 +34,6 @@ type Route struct {
 
 	LastSeen time.Time
 
-	// ZoneNames may be empty between learning the existence of a route and
-	// receiving zone information.
-	ZoneNames StringSet
-
 	// Exactly one of the following should be set
 	AURPPeer        *AURPPeer      // Next hop is this peer router (over AURP)
 	EtherTalkPeer   *EtherTalkPeer // Next hop is this peer router (over EtherTalk)
@@ -51,13 +47,6 @@ func (r Route) LastSeenAgo() string {
 	return fmt.Sprintf("%v ago", time.Since(r.LastSeen).Truncate(time.Millisecond))
 }
 
-// Valid reports whether the route is valid.
-// A valid route has one or more zone names, and if it is learned from a peer
-// router over EtherTalk is not too old.
-func (r *Route) Valid() bool {
-	return len(r.ZoneNames) > 0 && (r.EtherTalkPeer == nil || time.Since(r.LastSeen) <= maxRouteAge)
-}
-
 type RouteTable struct {
 	mu     sync.Mutex
 	routes map[*Route]struct{}
@@ -76,7 +65,6 @@ func (rt *RouteTable) InsertEtherTalkDirect(port *EtherTalkPort) {
 		NetEnd:          port.NetEnd,
 		Distance:        0, // we're connected directly
 		LastSeen:        time.Now(),
-		ZoneNames:       port.AvailableZones,
 		EtherTalkDirect: port,
 	}
 
@@ -105,7 +93,8 @@ func (rt *RouteTable) LookupRoute(network ddp.Network) *Route {
 		if network < r.NetStart || network > r.NetEnd {
 			continue
 		}
-		if !r.Valid() {
+		// Exclude EtherTalk routes that are too old
+		if r.EtherTalkPeer != nil && time.Since(r.LastSeen) > maxRouteAge {
 			continue
 		}
 		if bestRoute == nil {
@@ -153,12 +142,12 @@ func (rt *RouteTable) UpdateAURPRouteDistance(peer *AURPPeer, network ddp.Networ
 	}
 }
 
-func (rt *RouteTable) UpsertEtherTalkRoute(peer *EtherTalkPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) (*Route, error) {
+func (rt *RouteTable) UpsertEtherTalkRoute(peer *EtherTalkPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error {
 	if netStart > netEnd {
-		return nil, fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd)
+		return fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd)
 	}
 	if netStart != netEnd && !extended {
-		return nil, fmt.Errorf("invalid network range [%d, %d] for nonextended network", netStart, netEnd)
+		return fmt.Errorf("invalid network range [%d, %d] for nonextended network", netStart, netEnd)
 	}
 
 	rt.mu.Lock()
@@ -180,7 +169,7 @@ func (rt *RouteTable) UpsertEtherTalkRoute(peer *EtherTalkPeer, extended bool, n
 		}
 		r.Distance = metric
 		r.LastSeen = time.Now()
-		return r, nil
+		return nil
 	}
 
 	// Insert.
@@ -193,7 +182,7 @@ func (rt *RouteTable) UpsertEtherTalkRoute(peer *EtherTalkPeer, extended bool, n
 		EtherTalkPeer: peer,
 	}
 	rt.routes[r] = struct{}{}
-	return r, nil
+	return nil
 }
 
 func (rt *RouteTable) InsertAURPRoute(peer *AURPPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error {
@@ -219,29 +208,13 @@ func (rt *RouteTable) InsertAURPRoute(peer *AURPPeer, extended bool, netStart, n
 	return nil
 }
 
-// ValidRoutes returns all valid routes.
 func (rt *RouteTable) ValidRoutes() []*Route {
 	rt.mu.Lock()
 	defer rt.mu.Unlock()
 	valid := make([]*Route, 0, len(rt.routes))
 	for r := range rt.routes {
-		if r.Valid() {
+		// Exclude EtherTalk routes that are too old
-			valid = append(valid, r)
+		if r.EtherTalkPeer != nil && time.Since(r.LastSeen) > maxRouteAge {
-		}
-	}
-	return valid
-}
-
-// ValidNonAURPRoutes returns all valid routes that were not learned via AURP.
-func (rt *RouteTable) ValidNonAURPRoutes() []*Route {
-	rt.mu.Lock()
-	defer rt.mu.Unlock()
-	valid := make([]*Route, 0, len(rt.routes))
-	for r := range rt.routes {
-		if r.AURPPeer != nil {
-			continue
-		}
-		if !r.Valid() {
 			continue
 		}
 		valid = append(valid, r)

router/router.go

@@ -26,6 +26,7 @@ import (
 type Router struct {
 	Config     *Config
 	RouteTable *RouteTable
+	ZoneTable  *ZoneTable
 	Ports      []*EtherTalkPort
 }
 

router/rtmp.go

@@ -24,7 +24,6 @@ import (
 
 	"gitea.drjosh.dev/josh/jrouter/atalk"
 	"gitea.drjosh.dev/josh/jrouter/atalk/rtmp"
-	"gitea.drjosh.dev/josh/jrouter/atalk/zip"
 	"gitea.drjosh.dev/josh/jrouter/status"
 
 	"github.com/sfiera/multitalk/pkg/ddp"
@@ -102,7 +101,8 @@ func (port *EtherTalkPort) HandleRTMP(ctx context.Context, pkt *ddp.ExtPacket) e
 			}
 
 		case rtmp.FunctionLoopProbe:
-			return fmt.Errorf("TODO: handle Loop Probes")
+			log.Print("RTMP: TODO: handle Loop Probes")
+			return nil
 		}
 
 	case ddp.ProtoRTMPResp:
@@ -110,51 +110,22 @@ func (port *EtherTalkPort) HandleRTMP(ctx context.Context, pkt *ddp.ExtPacket) e
 		log.Print("RTMP: Got Response or Data")
 		dataPkt, err := rtmp.UnmarshalDataPacket(pkt.Data)
 		if err != nil {
-			return fmt.Errorf("unmarshal RTMP Data packet: %w", err)
+			log.Printf("RTMP: Couldn't unmarshal RTMP Data packet: %v", err)
+			break
 		}
 		peer := &EtherTalkPeer{
 			Port:     port,
 			PeerAddr: dataPkt.RouterAddr,
 		}
 
-		var noZones []ddp.Network
+		for _, rt := range dataPkt.NetworkTuples {
-		for _, nt := range dataPkt.NetworkTuples {
+			if err := port.Router.RouteTable.UpsertEtherTalkRoute(peer, rt.Extended, rt.RangeStart, rt.RangeEnd, rt.Distance+1); err != nil {
-			route, err := port.Router.RouteTable.UpsertEtherTalkRoute(peer, nt.Extended, nt.RangeStart, nt.RangeEnd, nt.Distance+1)
+				log.Printf("RTMP: Couldn't upsert EtherTalk route: %v", err)
-			if err != nil {
-				return fmt.Errorf("upsert EtherTalk route: %v", err)
-			}
-			if len(route.ZoneNames) == 0 {
-				noZones = append(noZones, route.NetStart)
-			}
-		}
-		if len(noZones) > 0 {
-			// Send a ZIP Query for all networks we don't have zone names for.
-			// TODO: split networks to fit in multiple packets as needed
-			qryPkt, err := (&zip.QueryPacket{Networks: noZones}).Marshal()
-			if err != nil {
-				return fmt.Errorf("marshal ZIP Query packet: %w", err)
-			}
-			outDDP := &ddp.ExtPacket{
-				ExtHeader: ddp.ExtHeader{
-					Size:      uint16(len(qryPkt)) + atalk.DDPExtHeaderSize,
-					Cksum:     0,
-					SrcNet:    port.MyAddr.Network,
-					SrcNode:   port.MyAddr.Node,
-					SrcSocket: 6,
-					DstNet:    pkt.SrcNet,
-					DstNode:   pkt.SrcNode,
-					DstSocket: 6, // ZIP socket
-					Proto:     ddp.ProtoZIP,
-				},
-				Data: qryPkt,
-			}
-			if err := port.Send(ctx, outDDP); err != nil {
-				return fmt.Errorf("sending ZIP Query: %w", err)
 			}
 		}
 
 	default:
-		return fmt.Errorf("invalid DDP type %d on socket 1", pkt.Proto)
+		log.Printf("RTMP: invalid DDP type %d on socket 1", pkt.Proto)
 	}
 
 	return nil

router/zip.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"slices"
 
 	"gitea.drjosh.dev/josh/jrouter/atalk"
 	"gitea.drjosh.dev/josh/jrouter/atalk/atp"
@@ -51,9 +52,6 @@ func (port *EtherTalkPort) handleZIPZIP(ctx context.Context, ddpkt *ddp.ExtPacke
 	case *zip.QueryPacket:
 		return port.handleZIPQuery(ctx, ddpkt, zipkt)
 
-	case *zip.ReplyPacket:
-		return port.handleZIPReply(zipkt)
-
 	case *zip.GetNetInfoPacket:
 		return port.handleZIPGetNetInfo(ctx, ddpkt, zipkt)
 
@@ -64,7 +62,7 @@ func (port *EtherTalkPort) handleZIPZIP(ctx context.Context, ddpkt *ddp.ExtPacke
 
 func (port *EtherTalkPort) handleZIPQuery(ctx context.Context, ddpkt *ddp.ExtPacket, zipkt *zip.QueryPacket) error {
 	log.Printf("ZIP: Got Query for networks %v", zipkt.Networks)
-	networks := port.Router.RouteTable.ZonesForNetworks(zipkt.Networks)
+	networks := port.Router.ZoneTable.Query(zipkt.Networks)
 
 	sendReply := func(resp *zip.ReplyPacket) error {
 		respRaw, err := resp.Marshal()
@@ -158,21 +156,11 @@ func (port *EtherTalkPort) handleZIPQuery(ctx context.Context, ddpkt *ddp.ExtPac
 	return nil
 }
 
-func (port *EtherTalkPort) handleZIPReply(zipkt *zip.ReplyPacket) error {
-	log.Printf("ZIP: Got Reply containing %v", zipkt.Networks)
-
-	// Integrate new zone information into route table.
-	for n, zs := range zipkt.Networks {
-		port.Router.RouteTable.AddZonesToNetwork(n, zs...)
-	}
-	return nil
-}
-
 func (port *EtherTalkPort) handleZIPGetNetInfo(ctx context.Context, ddpkt *ddp.ExtPacket, zipkt *zip.GetNetInfoPacket) error {
 	log.Printf("ZIP: Got GetNetInfo for zone %q", zipkt.ZoneName)
 
 	// The request is zoneValid if the zone name is available on this network.
-	zoneValid := port.AvailableZones.Contains(zipkt.ZoneName)
+	zoneValid := slices.Contains(port.AvailableZones, zipkt.ZoneName)
 
 	// The multicast address we return depends on the validity of the zone
 	// name.
@@ -270,10 +258,10 @@ func (port *EtherTalkPort) handleZIPTReq(ctx context.Context, ddpkt *ddp.ExtPack
 
 	switch gzl.Function {
 	case zip.FunctionGetZoneList:
-		resp.Zones = port.Router.RouteTable.AllZoneNames()
+		resp.Zones = port.Router.ZoneTable.AllNames()
 
 	case zip.FunctionGetLocalZones:
-		resp.Zones = port.AvailableZones.ToSlice()
+		resp.Zones = port.AvailableZones
 
 	case zip.FunctionGetMyZone:
 		// Note: This shouldn't happen on extended networks (e.g. EtherTalk)

router/zones.go

@@ -17,72 +17,145 @@
 package router
 
 import (
+	"fmt"
 	"slices"
+	"sort"
+	"sync"
+	"time"
 
 	"github.com/sfiera/multitalk/pkg/ddp"
 )
 
-func (rt *RouteTable) AddZonesToNetwork(n ddp.Network, zs ...string) {
+//const maxZoneAge = 10 * time.Minute // TODO: confirm
-	rt.mu.Lock()
+
-	defer rt.mu.Unlock()
+type Zone struct {
-	for r := range rt.routes {
+	Network   ddp.Network
-		if n < r.NetStart || n > r.NetEnd {
+	Name      string
-			continue
+	LocalPort *EtherTalkPort // nil if remote (local to another router)
-		}
+	LastSeen  time.Time
-		if r.ZoneNames == nil {
+}
-			r.ZoneNames = make(StringSet)
+
-		}
+func (z Zone) LastSeenAgo() string {
-		r.ZoneNames.Insert(zs...)
+	if z.LastSeen.IsZero() {
+		return "never"
+	}
+	return fmt.Sprintf("%v ago", time.Since(z.LastSeen).Truncate(time.Millisecond))
+}
+
+type zoneKey struct {
+	network ddp.Network
+	name    string
+}
+
+type ZoneTable struct {
+	mu    sync.Mutex
+	zones map[zoneKey]*Zone
+}
+
+func NewZoneTable() *ZoneTable {
+	return &ZoneTable{
+		zones: make(map[zoneKey]*Zone),
 	}
 }
 
-func (rt *RouteTable) ZonesForNetworks(ns []ddp.Network) map[ddp.Network][]string {
+func (zt *ZoneTable) Dump() []Zone {
+	zt.mu.Lock()
+	defer zt.mu.Unlock()
+	zs := make([]Zone, 0, len(zt.zones))
+	for _, z := range zt.zones {
+		zs = append(zs, *z)
+	}
+	return zs
+}
+
+func (zt *ZoneTable) Upsert(network ddp.Network, name string, localPort *EtherTalkPort) {
+	zt.mu.Lock()
+	defer zt.mu.Unlock()
+	key := zoneKey{network, name}
+	z := zt.zones[key]
+	if z != nil {
+		z.LocalPort = localPort
+		z.LastSeen = time.Now()
+		return
+	}
+	zt.zones[key] = &Zone{
+		Network:   network,
+		Name:      name,
+		LocalPort: localPort,
+		LastSeen:  time.Now(),
+	}
+}
+
+func (zt *ZoneTable) Query(ns []ddp.Network) map[ddp.Network][]string {
+	slices.Sort(ns)
 	zs := make(map[ddp.Network][]string)
 
-	rt.mu.Lock()
+	zt.mu.Lock()
-	defer rt.mu.Unlock()
+	defer zt.mu.Unlock()
-	for r := range rt.routes {
+	for _, z := range zt.zones {
-		if !r.Valid() {
+		// if time.Since(z.LastSeen) > maxZoneAge {
-			continue
+		// 	continue
-		}
+		// }
-		if _, ok := slices.BinarySearch(ns, r.NetStart); ok {
+		if _, ok := slices.BinarySearch(ns, z.Network); ok {
-			for z := range r.ZoneNames {
+			zs[z.Network] = append(zs[z.Network], z.Name)
-				zs[r.NetStart] = append(zs[r.NetStart], z)
-			}
 		}
 	}
 	return zs
 }
 
-func (rt *RouteTable) RoutesForZone(zone string) []*Route {
+func (zt *ZoneTable) LookupName(name string) []*Zone {
-	rt.mu.Lock()
+	zt.mu.Lock()
-	defer rt.mu.Unlock()
+	defer zt.mu.Unlock()
 
-	var routes []*Route
+	var zs []*Zone
-	for r := range rt.routes {
+	for _, z := range zt.zones {
-		if !r.Valid() {
+		if z.Name == name {
-			continue
+			zs = append(zs, z)
-		}
-		if r.ZoneNames.Contains(zone) {
-			routes = append(routes, r)
 		}
 	}
-	return routes
+	return zs
 }
 
-func (rt *RouteTable) AllZoneNames() (zones []string) {
+// func (zt *ZoneTable) LocalNames() []string {
-	defer slices.Sort(zones)
+// 	zt.mu.Lock()
+// 	seen := make(map[string]struct{})
+// 	zs := make([]string, 0, len(zt.zones))
+// 	for _, z := range zt.zones {
+// 		// if time.Since(z.LastSeen) > maxZoneAge {
+// 		// 	continue
+// 		// }
+// 		if z.Local != nil {
+// 			continue
+// 		}
+// 		if _, s := seen[z.Name]; s {
+// 			continue
+// 		}
+// 		seen[z.Name] = struct{}{}
+// 		zs = append(zs, z.Name)
 
-	rt.mu.Lock()
+// 	}
-	defer rt.mu.Unlock()
+// 	zt.mu.Unlock()
 
-	zs := make(StringSet)
+// 	sort.Strings(zs)
-	for r := range rt.routes {
+// 	return zs
-		if !r.Valid() {
+// }
+
+func (zt *ZoneTable) AllNames() []string {
+	zt.mu.Lock()
+	seen := make(map[string]struct{})
+	zs := make([]string, 0, len(zt.zones))
+	for _, z := range zt.zones {
+		// if time.Since(z.LastSeen) > maxZoneAge {
+		// 	continue
+		// }
+		if _, s := seen[z.Name]; s {
 			continue
 		}
-		zs.Add(r.ZoneNames)
+		seen[z.Name] = struct{}{}
+		zs = append(zs, z.Name)
 	}
+	zt.mu.Unlock()
 
-	return zs.ToSlice()
+	sort.Strings(zs)
+	return zs
 }