Multi-port refactor

This commit is contained in:
Josh Deprez 2024-05-03 16:13:59 +10:00
parent 545087fbe8
commit a16191d9e4
No known key found for this signature in database
12 changed files with 717 additions and 633 deletions

239
main.go
View file

@ -23,7 +23,6 @@ import (
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"io"
"log" "log"
"math/rand/v2" "math/rand/v2"
"net" "net"
@ -44,7 +43,6 @@ import (
"github.com/google/gopacket/pcap" "github.com/google/gopacket/pcap"
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet" "github.com/sfiera/multitalk/pkg/ethernet"
"github.com/sfiera/multitalk/pkg/ethertalk"
) )
const routingTableTemplate = ` const routingTableTemplate = `
@ -159,10 +157,10 @@ func main() {
ln, err := net.ListenUDP("udp4", &net.UDPAddr{Port: int(cfg.ListenPort)}) ln, err := net.ListenUDP("udp4", &net.UDPAddr{Port: int(cfg.ListenPort)})
if err != nil { if err != nil {
log.Fatalf("Couldn't listen on udp4:387: %v", err) log.Fatalf("AURP: Couldn't listen on udp4:387: %v", err)
} }
defer ln.Close() defer ln.Close()
log.Printf("Listening on %v", ln.LocalAddr()) log.Printf("AURP: Listening on %v", ln.LocalAddr())
log.Println("Press ^C or send SIGINT to stop the router gracefully") log.Println("Press ^C or send SIGINT to stop the router gracefully")
cctx, cancel := context.WithCancel(context.Background()) cctx, cancel := context.WithCancel(context.Background())
@ -203,7 +201,7 @@ func main() {
defer pcapHandle.Close() defer pcapHandle.Close()
// -------------------------------- Tables -------------------------------- // -------------------------------- Tables --------------------------------
routes := router.NewRoutingTable() routes := router.NewRouteTable()
status.AddItem(ctx, "Routing table", routingTableTemplate, func(context.Context) (any, error) { status.AddItem(ctx, "Routing table", routingTableTemplate, func(context.Context) (any, error) {
rs := routes.Dump() rs := routes.Dump()
slices.SortFunc(rs, func(ra, rb router.Route) int { slices.SortFunc(rs, func(ra, rb router.Route) int {
@ -213,7 +211,6 @@ func main() {
}) })
zones := router.NewZoneTable() zones := router.NewZoneTable()
zones.Upsert(cfg.EtherTalk.NetStart, cfg.EtherTalk.ZoneName, true)
status.AddItem(ctx, "Zone table", zoneTableTemplate, func(context.Context) (any, error) { status.AddItem(ctx, "Zone table", zoneTableTemplate, func(context.Context) (any, error) {
zs := zones.Dump() zs := zones.Dump()
slices.SortFunc(zs, func(za, zb router.Zone) int { slices.SortFunc(zs, func(za, zb router.Zone) int {
@ -331,174 +328,52 @@ func main() {
// --------------------------------- AARP --------------------------------- // --------------------------------- AARP ---------------------------------
aarpMachine := router.NewAARPMachine(cfg, pcapHandle, myHWAddr) aarpMachine := router.NewAARPMachine(cfg, pcapHandle, myHWAddr)
aarpCh := make(chan *ethertalk.Packet, 1024) go aarpMachine.Run(ctx)
go aarpMachine.Run(ctx, aarpCh)
// --------------------------------- RTMP --------------------------------- // --------------------------------- RTMP ---------------------------------
rtmpMachine := &router.RTMPMachine{ rtmpMachine := &router.RTMPMachine{
AARP: aarpMachine, AARPMachine: aarpMachine,
Config: cfg, Config: cfg,
PcapHandle: pcapHandle, PcapHandle: pcapHandle,
RoutingTable: routes, RoutingTable: routes,
IncomingCh: make(chan *ddp.ExtPacket, 1024),
} }
rtmpCh := make(chan *ddp.ExtPacket, 1024) go rtmpMachine.Run(ctx)
go rtmpMachine.Run(ctx, rtmpCh)
// -------------------------------- Router -------------------------------- // -------------------------------- Router --------------------------------
rooter := &router.Router{ rooter := &router.Router{
Config: cfg, Config: cfg,
PcapHandle: pcapHandle,
MyHWAddr: myHWAddr,
// MyDDPAddr: ...,
AARPMachine: aarpMachine,
RouteTable: routes, RouteTable: routes,
ZoneTable: zones, ZoneTable: zones,
} }
etherTalkPort := &router.EtherTalkPort{
EthernetAddr: myHWAddr,
NetStart: cfg.EtherTalk.NetStart,
NetEnd: cfg.EtherTalk.NetEnd,
DefaultZoneName: cfg.EtherTalk.ZoneName,
AvailableZones: []string{cfg.EtherTalk.ZoneName},
PcapHandle: pcapHandle,
AARPMachine: aarpMachine,
RTMPMachine: rtmpMachine,
Router: rooter,
}
routes.InsertEtherTalkDirect(etherTalkPort)
for _, az := range etherTalkPort.AvailableZones {
zones.Upsert(etherTalkPort.NetStart, az, etherTalkPort)
}
// ---------------------- Raw AppleTalk/AARP inbound ---------------------- // ---------------------- Raw AppleTalk/AARP inbound ----------------------
wg.Add(1) wg.Add(1)
go func() { go func() {
defer wg.Done() defer wg.Done()
ctx, setStatus, done := status.AddSimpleItem(ctx, "EtherTalk inbound") ctx, setStatus, _ := status.AddSimpleItem(ctx, "EtherTalk inbound")
defer done() defer setStatus("EtherTalk Serve goroutine exited!")
setStatus(fmt.Sprintf("Listening on %s", cfg.EtherTalk.Device)) setStatus(fmt.Sprintf("Listening on %s", cfg.EtherTalk.Device))
for { etherTalkPort.Serve(ctx)
if ctx.Err() != nil {
return
}
rawPkt, _, err := pcapHandle.ReadPacketData()
if errors.Is(err, pcap.NextErrorTimeoutExpired) {
continue
}
if errors.Is(err, io.EOF) || errors.Is(err, pcap.NextErrorNoMorePackets) {
return
}
if err != nil {
log.Printf("Couldn't read AppleTalk / AARP packet data: %v", err)
return
}
ethFrame := new(ethertalk.Packet)
if err := ethertalk.Unmarshal(rawPkt, ethFrame); err != nil {
log.Printf("Couldn't unmarshal EtherTalk frame: %v", err)
continue
}
// Ignore if sent by me
if ethFrame.Src == myHWAddr {
continue
}
switch ethFrame.SNAPProto {
case ethertalk.AARPProto:
// log.Print("Got an AARP frame")
aarpCh <- ethFrame
case ethertalk.AppleTalkProto:
// log.Print("Got an AppleTalk frame")
ddpkt := new(ddp.ExtPacket)
if err := ddp.ExtUnmarshal(ethFrame.Payload, ddpkt); err != nil {
log.Printf("Couldn't unmarshal DDP packet: %v", err)
continue
}
log.Printf("DDP: src (%d.%d s %d) dst (%d.%d s %d) proto %d data len %d",
ddpkt.SrcNet, ddpkt.SrcNode, ddpkt.SrcSocket,
ddpkt.DstNet, ddpkt.DstNode, ddpkt.DstSocket,
ddpkt.Proto, len(ddpkt.Data))
// Glean address info for AMT, but only if SrcNet is our net
// (If it's not our net, then it was routed from elsewhere, and
// we'd be filling the AMT with entries for a router.)
if ddpkt.SrcNet >= cfg.EtherTalk.NetStart && ddpkt.SrcNet <= cfg.EtherTalk.NetEnd {
srcAddr := ddp.Addr{Network: ddpkt.SrcNet, Node: ddpkt.SrcNode}
aarpMachine.Learn(srcAddr, ethFrame.Src)
// log.Printf("DDP: Gleaned that %d.%d -> %v", srcAddr.Network, srcAddr.Node, ethFrame.Src)
}
// Packet for us? First, who am I?
myAddr, ok := aarpMachine.Address()
if !ok {
continue
}
rooter.MyDDPAddr = myAddr.Proto
// Our network?
// "The network number 0 is reserved to mean unknown; by default
// it specifies the local network to which the node is
// connected. Packets whose destination network number is 0 are
// addressed to a node on the local network."
// TODO: more generic routing
if ddpkt.DstNet != 0 && !(ddpkt.DstNet >= cfg.EtherTalk.NetStart && ddpkt.DstNet <= cfg.EtherTalk.NetEnd) {
// Is it for a network in the routing table?
route := routes.LookupRoute(ddpkt.DstNet)
if route == nil {
log.Printf("DDP: no route for network %d", ddpkt.DstNet)
continue
}
switch {
case route.AURPPeer != nil:
// Encap ethPacket.Payload into an AURP packet
log.Printf("DDP: forwarding to AURP peer %v", route.AURPPeer.RemoteAddr)
if _, err := route.AURPPeer.Send(route.AURPPeer.Transport.NewAppleTalkPacket(ethFrame.Payload)); err != nil {
log.Printf("DDP: Couldn't forward packet to AURP peer: %v", err)
}
case route.EtherTalkPeer != nil:
// Route payload to another router over EtherTalk
// TODO: this is unlikely because we currenly only support 1 EtherTalk port
log.Printf("DDP: forwarding to EtherTalk peer %v", route.EtherTalkPeer.PeerAddr)
// Note: resolving AARP can block
if err := route.EtherTalkPeer.Forward(ctx, ddpkt); err != nil {
log.Printf("DDP: Couldn't forward packet to EtherTalk peer: %v", err)
}
default:
log.Print("DDP: no forwarding mechanism for route; dropping packet")
}
continue
}
// To me?
// "Node ID 0 indicates any router on the network"- I'm a router
// "node ID $FF indicates either a network-wide or zone-specific
// broadcast"- that's relevant
if ddpkt.DstNode != 0 && ddpkt.DstNode != 0xff && ddpkt.DstNode != myAddr.Proto.Node {
continue
}
switch ddpkt.DstSocket {
case 1: // The RTMP socket
rtmpCh <- ddpkt
case 2: // The NIS (name information socket / NBP socket)
if err := rooter.HandleNBP(ethFrame.Src, ddpkt); err != nil {
log.Printf("NBP: Couldn't handle: %v", err)
}
case 4: // The AEP socket
if err := rooter.HandleAEP(ethFrame.Src, ddpkt); err != nil {
log.Printf("AEP: Couldn't handle: %v", err)
}
case 6: // The ZIS (zone information socket / ZIP socket)
if err := rooter.HandleZIP(ctx, ethFrame.Src, ddpkt); err != nil {
log.Printf("ZIP: couldn't handle: %v", err)
}
default:
log.Printf("DDP: No handler for socket %d", ddpkt.DstSocket)
}
default:
log.Printf("Read unknown packet %s -> %s with payload %x", ethFrame.Src, ethFrame.Dst, ethFrame.Payload)
}
}
}() }()
// ----------------------------- AURP inbound ----------------------------- // ----------------------------- AURP inbound -----------------------------
@ -598,74 +473,24 @@ func main() {
ddpkt.DstNet, ddpkt.DstNode, ddpkt.DstSocket, ddpkt.DstNet, ddpkt.DstNode, ddpkt.DstSocket,
ddpkt.Proto, len(ddpkt.Data)) ddpkt.Proto, len(ddpkt.Data))
// Route the packet // Is it addressed to me?
// Check and adjust the Hop Count
// Note the ddp package doesn't make this simple
hopCount := (ddpkt.Size & 0x3C00) >> 10
if hopCount >= 15 {
log.Printf("DDP/AURP: hop count exceeded (%d >= 15)", hopCount)
continue
}
hopCount++
ddpkt.Size &^= 0x3C00
ddpkt.Size |= hopCount << 10
if ddpkt.DstNet < cfg.EtherTalk.NetStart || ddpkt.DstNet > cfg.EtherTalk.NetEnd {
// Is it a network in the routing table?
route := routes.LookupRoute(ddpkt.DstNet)
if route == nil {
log.Printf("DDP/AURP: no route for packet (dstnet %d); dropping packet", ddpkt.DstNet)
break
}
switch {
case route.AURPPeer != nil:
// Routing between AURP peers... bit weird but OK
log.Printf("DDP/AURP: forwarding to AURP peer %v", route.AURPPeer.RemoteAddr)
outPkt, err := ddp.ExtMarshal(*ddpkt)
if err != nil {
log.Printf("DDP/AURP: Couldn't re-marshal packet: %v", err)
break
}
if _, err := route.AURPPeer.Send(route.AURPPeer.Transport.NewAppleTalkPacket(outPkt)); err != nil {
log.Printf("DDP/AURP: Couldn't forward packet to AURP peer: %v", err)
}
case route.EtherTalkPeer != nil:
// AURP peer -> EtherTalk peer
// Note: resolving AARP can block
log.Printf("DDP/AURP: forwarding to EtherTalk peer %v", route.EtherTalkPeer.PeerAddr)
if err := route.EtherTalkPeer.Forward(ctx, ddpkt); err != nil {
log.Printf("DDP/AURP: Couldn't forward packet to EtherTalk peer: %v", err)
}
default:
log.Print("DDP/AURP: no forwarding mechanism for route; dropping packet")
}
continue
}
// Is it addressed to me? Is it NBP?
if ddpkt.DstNode == 0 { // Node 0 = any router for the network = me if ddpkt.DstNode == 0 { // Node 0 = any router for the network = me
// Is it NBP? FwdReq needs translating.
if ddpkt.DstSocket != 2 { if ddpkt.DstSocket != 2 {
// Something else?? TODO // Something else?? TODO
log.Printf("DDP/AURP: I don't have anything 'listening' on socket %d", ddpkt.DstSocket) log.Printf("DDP/AURP: I don't have anything 'listening' on socket %d", ddpkt.DstSocket)
continue continue
} }
// It's NBP // It's NBP
if err := rooter.HandleNBPInAURP(pr, ddpkt); err != nil { if err := rooter.HandleNBPInAURP(ctx, pr, ddpkt); err != nil {
log.Printf("NBP/DDP/AURP: %v", err) log.Printf("NBP/DDP/AURP: %v", err)
} }
continue
} }
// Note: resolving AARP can block // Route the packet
if err := rooter.SendEtherTalkDDP(ctx, ddpkt); err != nil { if err := rooter.Forward(ctx, ddpkt); err != nil {
log.Printf("DDP/AURP: couldn't send Ethertalk out: %v", err) log.Printf("DDP/AURP: Couldn't route packet: %v", err)
} }
continue
default: default:
log.Printf("AURP: Got unknown packet type %v", dh.PacketType) log.Printf("AURP: Got unknown packet type %v", dh.PacketType)

View file

@ -73,6 +73,8 @@ type AARPMachine struct {
cfg *Config cfg *Config
pcapHandle *pcap.Handle pcapHandle *pcap.Handle
incomingCh chan *ethertalk.Packet
// The Run goroutine is responsible for all writes to myAddr.Proto and // The Run goroutine is responsible for all writes to myAddr.Proto and
// probes, so this mutex is not used to enforce a single writer, only // probes, so this mutex is not used to enforce a single writer, only
// consistent reads // consistent reads
@ -90,6 +92,7 @@ func NewAARPMachine(cfg *Config, pcapHandle *pcap.Handle, myHWAddr ethernet.Addr
addressMappingTable: new(addressMappingTable), addressMappingTable: new(addressMappingTable),
cfg: cfg, cfg: cfg,
pcapHandle: pcapHandle, pcapHandle: pcapHandle,
incomingCh: make(chan *ethertalk.Packet, 1024), // arbitrary capacity
myAddr: aarp.AddrPair{ myAddr: aarp.AddrPair{
Hardware: myHWAddr, Hardware: myHWAddr,
}, },
@ -97,6 +100,14 @@ func NewAARPMachine(cfg *Config, pcapHandle *pcap.Handle, myHWAddr ethernet.Addr
} }
} }
// Handle handles a packet.
func (a *AARPMachine) Handle(ctx context.Context, pkt *ethertalk.Packet) {
select {
case <-ctx.Done():
case a.incomingCh <- pkt:
}
}
// Address returns the address of this node, and reports if the address is valid // Address returns the address of this node, and reports if the address is valid
// (i.e. not tentative). // (i.e. not tentative).
func (a *AARPMachine) Address() (aarp.AddrPair, bool) { func (a *AARPMachine) Address() (aarp.AddrPair, bool) {
@ -123,7 +134,7 @@ func (a *AARPMachine) status(ctx context.Context) (any, error) {
} }
// Run executes the machine. // Run executes the machine.
func (a *AARPMachine) Run(ctx context.Context, incomingCh <-chan *ethertalk.Packet) error { func (a *AARPMachine) Run(ctx context.Context) error {
ctx, done := status.AddItem(ctx, "AARP", aarpStatusTemplate, a.status) ctx, done := status.AddItem(ctx, "AARP", aarpStatusTemplate, a.status)
defer done() defer done()
@ -165,9 +176,9 @@ func (a *AARPMachine) Run(ctx context.Context, incomingCh <-chan *ethertalk.Pack
log.Printf("Couldn't broadcast a Probe: %v", err) log.Printf("Couldn't broadcast a Probe: %v", err)
} }
case ethFrame, ok := <-incomingCh: case ethFrame, ok := <-a.incomingCh:
if !ok { if !ok {
incomingCh = nil a.incomingCh = nil
} }
var aapkt aarp.Packet var aapkt aarp.Packet

View file

@ -17,14 +17,14 @@
package router package router
import ( import (
"context"
"fmt" "fmt"
"gitea.drjosh.dev/josh/jrouter/atalk/aep" "gitea.drjosh.dev/josh/jrouter/atalk/aep"
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet"
) )
func (rtr *Router) HandleAEP(src ethernet.Addr, ddpkt *ddp.ExtPacket) error { func (rtr *Router) HandleAEP(ctx context.Context, ddpkt *ddp.ExtPacket) error {
if ddpkt.Proto != ddp.ProtoAEP { if ddpkt.Proto != ddp.ProtoAEP {
return fmt.Errorf("invalid DDP type %d on socket 4", ddpkt.Proto) return fmt.Errorf("invalid DDP type %d on socket 4", ddpkt.Proto)
} }
@ -47,7 +47,7 @@ func (rtr *Router) HandleAEP(src ethernet.Addr, ddpkt *ddp.ExtPacket) error {
ddpkt.DstSocket, ddpkt.SrcSocket = ddpkt.SrcSocket, ddpkt.DstSocket ddpkt.DstSocket, ddpkt.SrcSocket = ddpkt.SrcSocket, ddpkt.DstSocket
ddpkt.Data[0] = byte(aep.EchoReply) ddpkt.Data[0] = byte(aep.EchoReply)
return rtr.sendEtherTalkDDP(src, ddpkt) return rtr.Forward(ctx, ddpkt)
default: default:
return fmt.Errorf("invalid AEP function %d", ep.Function) return fmt.Errorf("invalid AEP function %d", ep.Function)

View file

@ -17,16 +17,16 @@
package router package router
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"gitea.drjosh.dev/josh/jrouter/atalk" "gitea.drjosh.dev/josh/jrouter/atalk"
"gitea.drjosh.dev/josh/jrouter/atalk/nbp" "gitea.drjosh.dev/josh/jrouter/atalk/nbp"
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet"
) )
func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) error { func (port *EtherTalkPort) HandleNBP(ctx context.Context, ddpkt *ddp.ExtPacket) error {
if ddpkt.Proto != ddp.ProtoNBP { if ddpkt.Proto != ddp.ProtoNBP {
return fmt.Errorf("invalid DDP type %d on socket 2", ddpkt.Proto) return fmt.Errorf("invalid DDP type %d on socket 2", ddpkt.Proto)
} }
@ -41,23 +41,27 @@ func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) erro
switch nbpkt.Function { switch nbpkt.Function {
case nbp.FunctionLkUp: case nbp.FunctionLkUp:
// when in AppleTalk, do as Apple Internet Router does... // when in AppleTalk, do as Apple Internet Router does...
outDDP, err := rtr.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, &nbpkt.Tuples[0]) outDDP, err := port.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, &nbpkt.Tuples[0])
if err != nil || outDDP == nil { if err != nil || outDDP == nil {
return err return err
} }
log.Print("NBP: Replying to LkUp with LkUp-Reply for myself") log.Print("NBP: Replying to LkUp with LkUp-Reply for myself")
return rtr.sendEtherTalkDDP(srcHWAddr, outDDP) // Note: AARP can block
return port.Send(ctx, outDDP)
case nbp.FunctionFwdReq:
// TODO: handle FwdReq in
case nbp.FunctionBrRq: case nbp.FunctionBrRq:
// There must be 1! // There must be 1!
tuple := &nbpkt.Tuples[0] tuple := &nbpkt.Tuples[0]
zones := rtr.ZoneTable.LookupName(tuple.Zone) zones := port.Router.ZoneTable.LookupName(tuple.Zone)
for _, z := range zones { for _, z := range zones {
if z.Local { if outPort := z.LocalPort; outPort != nil {
// If it's for the local zone, translate it to a LkUp and broadcast it back // If it's for a local zone, translate it to a LkUp and broadcast
// out the EtherTalk port. // out the corresponding EtherTalk port.
// "Note: On an internet, nodes on extended networks performing lookups in // "Note: On an internet, nodes on extended networks performing lookups in
// their own zone must replace a zone name of asterisk (*) with their actual // their own zone must replace a zone name of asterisk (*) with their actual
// zone name before sending the packet to A-ROUTER. All nodes performing // zone name before sending the packet to A-ROUTER. All nodes performing
@ -86,35 +90,26 @@ func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) erro
} }
log.Printf("NBP: zone multicasting LkUp for tuple %v", tuple) log.Printf("NBP: zone multicasting LkUp for tuple %v", tuple)
if err := rtr.ZoneMulticastEtherTalkDDP(tuple.Zone, &outDDP); err != nil { if err := outPort.ZoneMulticast(tuple.Zone, &outDDP); err != nil {
return err return err
} }
// But also...if we match the query, reply as though it was a LkUp // But also...if we match the query, reply as though it was a LkUp
outDDP2, err := rtr.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, tuple) outDDP2, err := outPort.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, tuple)
if err != nil { if err != nil {
return err return err
} }
if outDDP2 == nil { if outDDP2 == nil {
continue continue
} }
log.Print("NBP: Replying to BrRq with LkUp-Reply for myself") log.Print("NBP: Replying to BrRq directly with LkUp-Reply for myself")
if err := rtr.sendEtherTalkDDP(srcHWAddr, outDDP2); err != nil { if err := port.Router.Forward(ctx, outDDP2); err != nil {
return err return err
} }
continue continue
} }
route := rtr.RouteTable.LookupRoute(z.Network)
if route == nil {
return fmt.Errorf("no route for network %d", z.Network)
}
peer := route.AURPPeer
if peer == nil {
return fmt.Errorf("nil peer for route for network %d", z.Network)
}
// Translate it into a FwdReq and route it to the // Translate it into a FwdReq and route it to the
// routers with the appropriate zone(s). // routers with the appropriate zone(s).
nbpkt.Function = nbp.FunctionFwdReq nbpkt.Function = nbp.FunctionFwdReq
@ -123,7 +118,7 @@ func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) erro
return fmt.Errorf("couldn't marshal FwdReq: %v", err) return fmt.Errorf("couldn't marshal FwdReq: %v", err)
} }
outDDP := ddp.ExtPacket{ outDDP := &ddp.ExtPacket{
ExtHeader: ddp.ExtHeader{ ExtHeader: ddp.ExtHeader{
Size: atalk.DDPExtHeaderSize + uint16(len(nbpRaw)), Size: atalk.DDPExtHeaderSize + uint16(len(nbpRaw)),
Cksum: 0, Cksum: 0,
@ -138,16 +133,7 @@ func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) erro
Data: nbpRaw, Data: nbpRaw,
} }
outDDPRaw, err := ddp.ExtMarshal(outDDP) return port.Router.Forward(ctx, outDDP)
if err != nil {
return err
}
log.Printf("NBP: Sending FwdReq to %v for tuple %v", peer.RemoteAddr, tuple)
if _, err := peer.Send(peer.Transport.NewAppleTalkPacket(outDDPRaw)); err != nil {
return fmt.Errorf("sending FwdReq on to peer: %w", err)
}
} }
default: default:
@ -157,14 +143,15 @@ func (rtr *Router) HandleNBP(srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) erro
return nil return nil
} }
func (rtr *Router) helloWorldThisIsMe(ddpkt *ddp.ExtPacket, nbpID uint8, tuple *nbp.Tuple) (*ddp.ExtPacket, error) { // Returns an NBP LkUp-Reply for the router itself, with the address from this port.
func (port *EtherTalkPort) helloWorldThisIsMe(ddpkt *ddp.ExtPacket, nbpID uint8, tuple *nbp.Tuple) (*ddp.ExtPacket, error) {
if tuple.Object != "jrouter" && tuple.Object != "=" { if tuple.Object != "jrouter" && tuple.Object != "=" {
return nil, nil return nil, nil
} }
if tuple.Type != "AppleRouter" && tuple.Type != "=" { if tuple.Type != "AppleRouter" && tuple.Type != "=" {
return nil, nil return nil, nil
} }
if tuple.Zone != rtr.Config.EtherTalk.ZoneName && tuple.Zone != "*" && tuple.Zone != "" { if tuple.Zone != port.DefaultZoneName && tuple.Zone != "*" && tuple.Zone != "" {
return nil, nil return nil, nil
} }
respPkt := &nbp.Packet{ respPkt := &nbp.Packet{
@ -172,13 +159,13 @@ func (rtr *Router) helloWorldThisIsMe(ddpkt *ddp.ExtPacket, nbpID uint8, tuple *
NBPID: nbpID, NBPID: nbpID,
Tuples: []nbp.Tuple{ Tuples: []nbp.Tuple{
{ {
Network: rtr.MyDDPAddr.Network, Network: port.MyAddr.Network,
Node: rtr.MyDDPAddr.Node, Node: port.MyAddr.Node,
Socket: 253, Socket: 253,
Enumerator: 0, Enumerator: 0,
Object: "jrouter", Object: "jrouter",
Type: "AppleRouter", Type: "AppleRouter",
Zone: rtr.Config.EtherTalk.ZoneName, Zone: port.DefaultZoneName,
}, },
}, },
} }
@ -193,8 +180,8 @@ func (rtr *Router) helloWorldThisIsMe(ddpkt *ddp.ExtPacket, nbpID uint8, tuple *
DstNet: ddpkt.SrcNet, DstNet: ddpkt.SrcNet,
DstNode: ddpkt.SrcNode, DstNode: ddpkt.SrcNode,
DstSocket: ddpkt.SrcSocket, DstSocket: ddpkt.SrcSocket,
SrcNet: rtr.MyDDPAddr.Network, SrcNet: port.MyAddr.Network,
SrcNode: rtr.MyDDPAddr.Node, SrcNode: port.MyAddr.Node,
SrcSocket: 2, SrcSocket: 2,
Proto: ddp.ProtoNBP, Proto: ddp.ProtoNBP,
}, },

View file

@ -17,6 +17,7 @@
package router package router
import ( import (
"context"
"fmt" "fmt"
"log" "log"
@ -24,7 +25,7 @@ import (
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
) )
func (rtr *Router) HandleNBPInAURP(peer *AURPPeer, ddpkt *ddp.ExtPacket) error { func (rtr *Router) HandleNBPInAURP(ctx context.Context, peer *AURPPeer, ddpkt *ddp.ExtPacket) error {
if ddpkt.Proto != ddp.ProtoNBP { if ddpkt.Proto != ddp.ProtoNBP {
return fmt.Errorf("invalid DDP type %d on socket 2", ddpkt.Proto) return fmt.Errorf("invalid DDP type %d on socket 2", ddpkt.Proto)
} }
@ -42,11 +43,12 @@ func (rtr *Router) HandleNBPInAURP(peer *AURPPeer, ddpkt *ddp.ExtPacket) error {
} }
tuple := &nbpkt.Tuples[0] tuple := &nbpkt.Tuples[0]
if tuple.Zone != rtr.Config.EtherTalk.ZoneName { zones := rtr.ZoneTable.LookupName(tuple.Zone)
return fmt.Errorf("FwdReq querying zone %q, which is not our zone", tuple.Zone) for _, z := range zones {
if z.LocalPort == nil {
continue
} }
port := z.LocalPort
// TODO: Route the FwdReq to another router if it's not our zone
log.Printf("NBP/DDP/AURP: Converting FwdReq to LkUp (%v)", tuple) log.Printf("NBP/DDP/AURP: Converting FwdReq to LkUp (%v)", tuple)
@ -65,20 +67,20 @@ func (rtr *Router) HandleNBPInAURP(peer *AURPPeer, ddpkt *ddp.ExtPacket) error {
ddpkt.DstNode = 0xFF // Broadcast node address within the dest network ddpkt.DstNode = 0xFF // Broadcast node address within the dest network
ddpkt.Data = nbpRaw ddpkt.Data = nbpRaw
if err := rtr.ZoneMulticastEtherTalkDDP(tuple.Zone, ddpkt); err != nil { if err := port.ZoneMulticast(tuple.Zone, ddpkt); err != nil {
return err return err
} }
// But also... if it matches us, reply directly with a LkUp-Reply of our own // But also... if it matches us, reply directly with a LkUp-Reply of our own
outDDP, err := rtr.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, tuple) outDDP, err := port.helloWorldThisIsMe(ddpkt, nbpkt.NBPID, tuple)
if err != nil || outDDP == nil { if err != nil || outDDP == nil {
return err return err
} }
log.Print("NBP/DDP/AURP: Replying to BrRq with LkUp-Reply for myself") log.Print("NBP/DDP/AURP: Replying to BrRq with LkUp-Reply for myself")
outDDPRaw, err := ddp.ExtMarshal(*outDDP) if err := rtr.Forward(ctx, outDDP); err != nil {
if err != nil {
return err return err
} }
_, err = peer.Send(peer.Transport.NewAppleTalkPacket(outDDPRaw)) }
return err
return nil
} }

View file

@ -115,7 +115,7 @@ type AURPPeer struct {
ReceiveCh chan aurp.Packet ReceiveCh chan aurp.Packet
// Routing table (the peer will add/remove/update routes) // Routing table (the peer will add/remove/update routes)
RoutingTable *RoutingTable RoutingTable *RouteTable
// Zone table (the peer will add/remove/update zones) // Zone table (the peer will add/remove/update zones)
ZoneTable *ZoneTable ZoneTable *ZoneTable
@ -125,6 +125,15 @@ type AURPPeer struct {
sstate SenderState sstate SenderState
} }
func (p *AURPPeer) Forward(ddpkt *ddp.ExtPacket) error {
outPkt, err := ddp.ExtMarshal(*ddpkt)
if err != nil {
return err
}
_, err = p.Send(p.Transport.NewAppleTalkPacket(outPkt))
return err
}
func (p *AURPPeer) ReceiverState() ReceiverState { func (p *AURPPeer) ReceiverState() ReceiverState {
p.mu.RLock() p.mu.RLock()
defer p.mu.RUnlock() defer p.mu.RUnlock()
@ -596,7 +605,7 @@ func (p *AURPPeer) Handle(ctx context.Context) error {
case *aurp.ZIRspPacket: case *aurp.ZIRspPacket:
log.Printf("AURP Peer: Learned about these zones: %v", pkt.Zones) log.Printf("AURP Peer: Learned about these zones: %v", pkt.Zones)
for _, zt := range pkt.Zones { for _, zt := range pkt.Zones {
p.ZoneTable.Upsert(ddp.Network(zt.Network), zt.Name, false) p.ZoneTable.Upsert(ddp.Network(zt.Network), zt.Name, nil)
} }
case *aurp.GDZLReqPacket: case *aurp.GDZLReqPacket:

190
router/port.go Normal file
View file

@ -0,0 +1,190 @@
/*
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
import (
"context"
"errors"
"io"
"log"
"gitea.drjosh.dev/josh/jrouter/atalk"
"github.com/google/gopacket/pcap"
"github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet"
"github.com/sfiera/multitalk/pkg/ethertalk"
)
// EtherTalkPort is all the data and helpers needed for EtherTalk on one port.
type EtherTalkPort struct {
EthernetAddr ethernet.Addr
NetStart ddp.Network
NetEnd ddp.Network
MyAddr ddp.Addr
DefaultZoneName string
AvailableZones []string
PcapHandle *pcap.Handle
AARPMachine *AARPMachine
RTMPMachine *RTMPMachine
Router *Router
}
func (port *EtherTalkPort) Serve(ctx context.Context) {
for {
if ctx.Err() != nil {
return
}
rawPkt, _, err := port.PcapHandle.ReadPacketData()
if errors.Is(err, pcap.NextErrorTimeoutExpired) {
continue
}
if errors.Is(err, io.EOF) || errors.Is(err, pcap.NextErrorNoMorePackets) {
return
}
if err != nil {
log.Printf("Couldn't read AppleTalk / AARP packet data: %v", err)
return
}
ethFrame := new(ethertalk.Packet)
if err := ethertalk.Unmarshal(rawPkt, ethFrame); err != nil {
log.Printf("Couldn't unmarshal EtherTalk frame: %v", err)
continue
}
// Ignore if sent by me
if ethFrame.Src == port.EthernetAddr {
continue
}
switch ethFrame.SNAPProto {
case ethertalk.AARPProto:
// log.Print("Got an AARP frame")
port.AARPMachine.Handle(ctx, ethFrame)
case ethertalk.AppleTalkProto:
// log.Print("Got an AppleTalk frame")
ddpkt := new(ddp.ExtPacket)
if err := ddp.ExtUnmarshal(ethFrame.Payload, ddpkt); err != nil {
log.Printf("Couldn't unmarshal DDP packet: %v", err)
continue
}
log.Printf("DDP: src (%d.%d s %d) dst (%d.%d s %d) proto %d data len %d",
ddpkt.SrcNet, ddpkt.SrcNode, ddpkt.SrcSocket,
ddpkt.DstNet, ddpkt.DstNode, ddpkt.DstSocket,
ddpkt.Proto, len(ddpkt.Data))
// Glean address info for AMT, but only if SrcNet is our net
// (If it's not our net, then it was routed from elsewhere, and
// we'd be filling the AMT with entries for a router.)
if ddpkt.SrcNet >= port.NetStart && ddpkt.SrcNet <= port.NetEnd {
srcAddr := ddp.Addr{Network: ddpkt.SrcNet, Node: ddpkt.SrcNode}
port.AARPMachine.Learn(srcAddr, ethFrame.Src)
// log.Printf("DDP: Gleaned that %d.%d -> %v", srcAddr.Network, srcAddr.Node, ethFrame.Src)
}
// Packet for us? First, who am I?
myAddr, ok := port.AARPMachine.Address()
if !ok {
continue
}
// Our network?
// "The network number 0 is reserved to mean unknown; by default
// it specifies the local network to which the node is
// connected. Packets whose destination network number is 0 are
// addressed to a node on the local network."
// TODO: more generic routing
if ddpkt.DstNet != 0 && !(ddpkt.DstNet >= port.NetStart && ddpkt.DstNet <= port.NetEnd) {
// Is it for a network in the routing table?
if err := port.Router.Forward(ctx, ddpkt); err != nil {
log.Printf("DDP: Couldn't forward packet: %v", err)
}
continue
}
// To me?
// "Node ID 0 indicates any router on the network"- I'm a router
// "node ID $FF indicates either a network-wide or zone-specific
// broadcast"- that's relevant
if ddpkt.DstNode != 0 && ddpkt.DstNode != 0xff && ddpkt.DstNode != myAddr.Proto.Node {
continue
}
switch ddpkt.DstSocket {
case 1: // The RTMP socket
port.RTMPMachine.Handle(ctx, ddpkt)
case 2: // The NIS (name information socket / NBP socket)
if err := port.HandleNBP(ctx, ddpkt); err != nil {
log.Printf("NBP: Couldn't handle: %v", err)
}
case 4: // The AEP socket
if err := port.Router.HandleAEP(ctx, ddpkt); err != nil {
log.Printf("AEP: Couldn't handle: %v", err)
}
case 6: // The ZIS (zone information socket / ZIP socket)
if err := port.HandleZIP(ctx, ddpkt); err != nil {
log.Printf("ZIP: couldn't handle: %v", err)
}
default:
log.Printf("DDP: No handler for socket %d", ddpkt.DstSocket)
}
default:
log.Printf("Read unknown packet %s -> %s with payload %x", ethFrame.Src, ethFrame.Dst, ethFrame.Payload)
}
}
}
func (port *EtherTalkPort) Send(ctx context.Context, pkt *ddp.ExtPacket) error {
dstEth := ethertalk.AppleTalkBroadcast
if pkt.DstNode != 0xFF {
de, err := port.AARPMachine.Resolve(ctx, ddp.Addr{Network: pkt.DstNet, Node: pkt.DstNode})
if err != nil {
return err
}
dstEth = de
}
return port.send(dstEth, pkt)
}
func (port *EtherTalkPort) Broadcast(pkt *ddp.ExtPacket) error {
return port.send(ethertalk.AppleTalkBroadcast, pkt)
}
func (port *EtherTalkPort) ZoneMulticast(zone string, pkt *ddp.ExtPacket) error {
return port.send(atalk.MulticastAddr(zone), pkt)
}
func (port *EtherTalkPort) send(dstEth ethernet.Addr, pkt *ddp.ExtPacket) error {
outFrame, err := ethertalk.AppleTalk(port.EthernetAddr, *pkt)
if err != nil {
return err
}
outFrame.Dst = dstEth
outFrameRaw, err := ethertalk.Marshal(*outFrame)
if err != nil {
return err
}
return port.PcapHandle.WritePacketData(outFrameRaw)
}

View file

@ -35,8 +35,9 @@ type Route struct {
LastSeen time.Time LastSeen time.Time
// Exactly one of the following should be set // Exactly one of the following should be set
AURPPeer *AURPPeer AURPPeer *AURPPeer // Next hop is this peer router (over AURP)
EtherTalkPeer *EtherTalkPeer EtherTalkPeer *EtherTalkPeer // Next hop is this peer router (over EtherTalk)
EtherTalkDirect *EtherTalkPort // Directly connected to this network (via EtherTalk)
} }
func (r Route) LastSeenAgo() string { func (r Route) LastSeenAgo() string {
@ -46,18 +47,33 @@ func (r Route) LastSeenAgo() string {
return fmt.Sprintf("%v ago", time.Since(r.LastSeen).Truncate(time.Millisecond)) return fmt.Sprintf("%v ago", time.Since(r.LastSeen).Truncate(time.Millisecond))
} }
type RoutingTable struct { type RouteTable struct {
mu sync.Mutex mu sync.Mutex
routes map[*Route]struct{} routes map[*Route]struct{}
} }
func NewRoutingTable() *RoutingTable { func NewRouteTable() *RouteTable {
return &RoutingTable{ return &RouteTable{
routes: make(map[*Route]struct{}), routes: make(map[*Route]struct{}),
} }
} }
func (rt *RoutingTable) Dump() []Route { func (rt *RouteTable) InsertEtherTalkDirect(port *EtherTalkPort) {
r := &Route{
Extended: true,
NetStart: port.NetStart,
NetEnd: port.NetEnd,
Distance: 0, // we're connected directly
LastSeen: time.Now(),
EtherTalkDirect: port,
}
rt.mu.Lock()
defer rt.mu.Unlock()
rt.routes[r] = struct{}{}
}
func (rt *RouteTable) Dump() []Route {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
@ -68,7 +84,7 @@ func (rt *RoutingTable) Dump() []Route {
return table return table
} }
func (rt *RoutingTable) LookupRoute(network ddp.Network) *Route { func (rt *RouteTable) LookupRoute(network ddp.Network) *Route {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
@ -92,7 +108,7 @@ func (rt *RoutingTable) LookupRoute(network ddp.Network) *Route {
return bestRoute return bestRoute
} }
func (rt *RoutingTable) DeleteAURPPeer(peer *AURPPeer) { func (rt *RouteTable) DeleteAURPPeer(peer *AURPPeer) {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
@ -103,7 +119,7 @@ func (rt *RoutingTable) DeleteAURPPeer(peer *AURPPeer) {
} }
} }
func (rt *RoutingTable) DeleteAURPPeerNetwork(peer *AURPPeer, network ddp.Network) { func (rt *RouteTable) DeleteAURPPeerNetwork(peer *AURPPeer, network ddp.Network) {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
@ -114,7 +130,7 @@ func (rt *RoutingTable) DeleteAURPPeerNetwork(peer *AURPPeer, network ddp.Networ
} }
} }
func (rt *RoutingTable) UpdateAURPRouteDistance(peer *AURPPeer, network ddp.Network, distance uint8) { func (rt *RouteTable) UpdateAURPRouteDistance(peer *AURPPeer, network ddp.Network, distance uint8) {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
@ -126,7 +142,7 @@ func (rt *RoutingTable) UpdateAURPRouteDistance(peer *AURPPeer, network ddp.Netw
} }
} }
func (rt *RoutingTable) UpsertEthRoute(peer *EtherTalkPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error { func (rt *RouteTable) UpsertEthRoute(peer *EtherTalkPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error {
if netStart > netEnd { if netStart > netEnd {
return fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd) return fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd)
} }
@ -169,7 +185,7 @@ func (rt *RoutingTable) UpsertEthRoute(peer *EtherTalkPeer, extended bool, netSt
return nil return nil
} }
func (rt *RoutingTable) InsertAURPRoute(peer *AURPPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error { func (rt *RouteTable) InsertAURPRoute(peer *AURPPeer, extended bool, netStart, netEnd ddp.Network, metric uint8) error {
if netStart > netEnd { if netStart > netEnd {
return fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd) return fmt.Errorf("invalid network range [%d, %d]", netStart, netEnd)
} }
@ -192,7 +208,7 @@ func (rt *RoutingTable) InsertAURPRoute(peer *AURPPeer, extended bool, netStart,
return nil return nil
} }
func (rt *RoutingTable) ValidRoutes() []*Route { func (rt *RouteTable) ValidRoutes() []*Route {
rt.mu.Lock() rt.mu.Lock()
defer rt.mu.Unlock() defer rt.mu.Unlock()
valid := make([]*Route, 0, len(rt.routes)) valid := make([]*Route, 0, len(rt.routes))

View file

@ -18,53 +18,50 @@ package router
import ( import (
"context" "context"
"fmt"
"gitea.drjosh.dev/josh/jrouter/atalk"
"github.com/google/gopacket/pcap"
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet"
"github.com/sfiera/multitalk/pkg/ethertalk"
) )
type Router struct { type Router struct {
Config *Config Config *Config
PcapHandle *pcap.Handle RouteTable *RouteTable
MyHWAddr ethernet.Addr
MyDDPAddr ddp.Addr
AARPMachine *AARPMachine
RouteTable *RoutingTable
ZoneTable *ZoneTable ZoneTable *ZoneTable
} }
func (rtr *Router) SendEtherTalkDDP(ctx context.Context, pkt *ddp.ExtPacket) error { // Forward routes a packet towards the right destination.
dstEth := ethertalk.AppleTalkBroadcast // It increments the hop count, then looks up the best route for the network,
if pkt.DstNode != 0xFF { // then transmits the packet according to the route.
de, err := rtr.AARPMachine.Resolve(ctx, ddp.Addr{Network: pkt.DstNet, Node: pkt.DstNode}) func (rtr *Router) Forward(ctx context.Context, ddpkt *ddp.ExtPacket) error {
if err != nil { // Check and adjust the Hop Count
return err // Note the ddp package doesn't make this simple
hopCount := (ddpkt.Size & 0x3C00) >> 10
if hopCount >= 15 {
return fmt.Errorf("hop count exceeded (%d >= 15)", hopCount)
} }
dstEth = de hopCount++
} ddpkt.Size &^= 0x3C00
return rtr.sendEtherTalkDDP(dstEth, pkt) ddpkt.Size |= hopCount << 10
}
func (rtr *Router) BroadcastEtherTalkDDP(pkt *ddp.ExtPacket) error { switch route := rtr.RouteTable.LookupRoute(ddpkt.DstNet); {
return rtr.sendEtherTalkDDP(ethertalk.AppleTalkBroadcast, pkt) case route == nil:
} return fmt.Errorf("no route for packet (dstnet %d); dropping packet", ddpkt.DstNet)
func (rtr *Router) ZoneMulticastEtherTalkDDP(zone string, pkt *ddp.ExtPacket) error { case route.AURPPeer != nil:
return rtr.sendEtherTalkDDP(atalk.MulticastAddr(zone), pkt) // log.Printf("Forwarding packet to AURP peer %v", route.AURPPeer.RemoteAddr)
} return route.AURPPeer.Forward(ddpkt)
func (rtr *Router) sendEtherTalkDDP(dstEth ethernet.Addr, pkt *ddp.ExtPacket) error { case route.EtherTalkPeer != nil:
outFrame, err := ethertalk.AppleTalk(rtr.MyHWAddr, *pkt) // log.Printf("Forwarding to EtherTalk peer %v", route.EtherTalkPeer.PeerAddr)
if err != nil { // Note: resolving AARP can block
return err return route.EtherTalkPeer.Forward(ctx, ddpkt)
case route.EtherTalkDirect != nil:
// log.Printf("Outputting to EtherTalk directly")
// Note: resolving AARP can block
return route.EtherTalkDirect.Send(ctx, ddpkt)
default:
return fmt.Errorf("no forwarding mechanism for route! %+v", route)
} }
outFrame.Dst = dstEth
outFrameRaw, err := ethertalk.Marshal(*outFrame)
if err != nil {
return err
}
return rtr.PcapHandle.WritePacketData(outFrameRaw)
} }

View file

@ -36,22 +36,33 @@ import (
// RTMPMachine implements RTMP on an AppleTalk network attached to the router. // RTMPMachine implements RTMP on an AppleTalk network attached to the router.
type RTMPMachine struct { type RTMPMachine struct {
AARP *AARPMachine AARPMachine *AARPMachine
Config *Config Config *Config
PcapHandle *pcap.Handle PcapHandle *pcap.Handle
RoutingTable *RoutingTable RoutingTable *RouteTable
IncomingCh chan *ddp.ExtPacket
}
func (m *RTMPMachine) Handle(ctx context.Context, pkt *ddp.ExtPacket) {
select {
case <-ctx.Done():
case m.IncomingCh <- pkt:
}
} }
// Run executes the machine. // Run executes the machine.
func (m *RTMPMachine) Run(ctx context.Context, incomingCh <-chan *ddp.ExtPacket) error { func (m *RTMPMachine) Run(ctx context.Context) (err error) {
ctx, setStatus, done := status.AddSimpleItem(ctx, "RTMP") ctx, setStatus, _ := status.AddSimpleItem(ctx, "RTMP")
defer done() defer func() {
setStatus(fmt.Sprintf("Run loop stopped! Return: %v", err))
}()
setStatus("Awaiting DDP address assignment") setStatus("Awaiting DDP address assignment")
// Await local address assignment before doing anything // Await local address assignment before doing anything
<-m.AARP.Assigned() <-m.AARPMachine.Assigned()
myAddr, ok := m.AARP.Address() myAddr, ok := m.AARPMachine.Address()
if !ok { if !ok {
return fmt.Errorf("AARP machine closed Assigned channel but Address is not valid") return fmt.Errorf("AARP machine closed Assigned channel but Address is not valid")
} }
@ -63,7 +74,7 @@ func (m *RTMPMachine) Run(ctx context.Context, incomingCh <-chan *ddp.ExtPacket)
log.Printf("RTMP: Couldn't broadcast Data: %v", err) log.Printf("RTMP: Couldn't broadcast Data: %v", err)
} }
setStatus("Packet loop") setStatus("Starting packet loop")
bcastTicker := time.NewTicker(10 * time.Second) bcastTicker := time.NewTicker(10 * time.Second)
defer bcastTicker.Stop() defer bcastTicker.Stop()
@ -74,11 +85,13 @@ func (m *RTMPMachine) Run(ctx context.Context, incomingCh <-chan *ddp.ExtPacket)
return ctx.Err() return ctx.Err()
case <-bcastTicker.C: case <-bcastTicker.C:
setStatus("Broadcasting RTMP Data")
if err := m.broadcastData(myAddr); err != nil { if err := m.broadcastData(myAddr); err != nil {
log.Printf("RTMP: Couldn't broadcast Data: %v", err) log.Printf("RTMP: Couldn't broadcast Data: %v", err)
} }
case pkt := <-incomingCh: case pkt := <-m.IncomingCh:
setStatus("Handling incoming packet")
switch pkt.Proto { switch pkt.Proto {
case ddp.ProtoRTMPReq: case ddp.ProtoRTMPReq:
// I can answer RTMP requests! // I can answer RTMP requests!
@ -88,7 +101,7 @@ func (m *RTMPMachine) Run(ctx context.Context, incomingCh <-chan *ddp.ExtPacket)
} }
// should be in the cache... // should be in the cache...
theirHWAddr, err := m.AARP.Resolve(ctx, ddp.Addr{Network: pkt.SrcNet, Node: pkt.SrcNode}) theirHWAddr, err := m.AARPMachine.Resolve(ctx, ddp.Addr{Network: pkt.SrcNet, Node: pkt.SrcNode})
if err != nil { if err != nil {
log.Printf("RTMP: Couldn't resolve %d.%d to a hardware address: %v", pkt.SrcNet, pkt.SrcNode, err) log.Printf("RTMP: Couldn't resolve %d.%d to a hardware address: %v", pkt.SrcNet, pkt.SrcNode, err)
continue continue
@ -173,8 +186,8 @@ func (m *RTMPMachine) Run(ctx context.Context, incomingCh <-chan *ddp.ExtPacket)
} }
peer := &EtherTalkPeer{ peer := &EtherTalkPeer{
PcapHandle: m.PcapHandle, PcapHandle: m.PcapHandle,
MyHWAddr: m.AARP.myAddr.Hardware, MyHWAddr: m.AARPMachine.myAddr.Hardware,
AARP: m.AARP, AARP: m.AARPMachine,
PeerAddr: dataPkt.RouterAddr, PeerAddr: dataPkt.RouterAddr,
} }

View file

@ -20,103 +20,29 @@ import (
"context" "context"
"fmt" "fmt"
"log" "log"
"slices"
"gitea.drjosh.dev/josh/jrouter/atalk" "gitea.drjosh.dev/josh/jrouter/atalk"
"gitea.drjosh.dev/josh/jrouter/atalk/atp" "gitea.drjosh.dev/josh/jrouter/atalk/atp"
"gitea.drjosh.dev/josh/jrouter/atalk/zip" "gitea.drjosh.dev/josh/jrouter/atalk/zip"
"github.com/sfiera/multitalk/pkg/ddp" "github.com/sfiera/multitalk/pkg/ddp"
"github.com/sfiera/multitalk/pkg/ethernet" "github.com/sfiera/multitalk/pkg/ethernet"
"github.com/sfiera/multitalk/pkg/ethertalk"
) )
func (rtr *Router) HandleZIP(ctx context.Context, srcHWAddr ethernet.Addr, ddpkt *ddp.ExtPacket) error { func (port *EtherTalkPort) HandleZIP(ctx context.Context, ddpkt *ddp.ExtPacket) error {
switch ddpkt.Proto { switch ddpkt.Proto {
case ddp.ProtoATP: case ddp.ProtoATP:
atpkt, err := atp.UnmarshalPacket(ddpkt.Data) return port.handleZIPATP(ctx, ddpkt)
if err != nil {
return err
}
switch atpkt := atpkt.(type) {
case *atp.TReq:
gzl, err := zip.UnmarshalTReq(atpkt)
if err != nil {
return err
}
if gzl.StartIndex == 0 {
return fmt.Errorf("ZIP ATP: received request with StartIndex = 0 (invalid)")
}
resp := &zip.GetZonesReplyPacket{
TID: gzl.TID,
LastFlag: true,
}
switch gzl.Function {
case zip.FunctionGetZoneList:
resp.Zones = rtr.ZoneTable.AllNames()
case zip.FunctionGetLocalZones:
resp.Zones = rtr.ZoneTable.LocalNames()
case zip.FunctionGetMyZone:
resp.Zones = []string{rtr.Config.EtherTalk.ZoneName}
}
// Inside AppleTalk SE, pp 8-8
if int(gzl.StartIndex) > len(resp.Zones) {
// "Note: A 0-byte response will be returned by a router if the
// index specified in the request is greater than the index of
// the last zone in the list (and the user bytes field will
// indicate no more zones)."
resp.Zones = nil
} else {
// Trim the zones list
// "zone names in the router are assumed to be numbered starting
// with 1"
resp.Zones = resp.Zones[gzl.StartIndex-1:]
size := 0
for i, z := range resp.Zones {
size += 1 + len(z) // length prefix plus string
if size > atp.MaxDataSize {
resp.LastFlag = false
resp.Zones = resp.Zones[:i]
break
}
}
}
respATP, err := resp.MarshalTResp()
if err != nil {
return err
}
ddpBody, err := respATP.Marshal()
if err != nil {
return err
}
respDDP := &ddp.ExtPacket{
ExtHeader: ddp.ExtHeader{
Size: uint16(len(ddpBody)) + atalk.DDPExtHeaderSize,
Cksum: 0,
DstNet: ddpkt.SrcNet,
DstNode: ddpkt.SrcNode,
DstSocket: ddpkt.SrcSocket,
SrcNet: rtr.MyDDPAddr.Network,
SrcNode: rtr.MyDDPAddr.Node,
SrcSocket: 6,
Proto: ddp.ProtoATP,
},
Data: ddpBody,
}
return rtr.sendEtherTalkDDP(srcHWAddr, respDDP)
case *atp.TResp:
return fmt.Errorf("TODO: support handling ZIP ATP replies?")
default:
return fmt.Errorf("unsupported ATP packet type %T for ZIP", atpkt)
}
case ddp.ProtoZIP: case ddp.ProtoZIP:
return port.handleZIPZIP(ctx, ddpkt)
default:
return fmt.Errorf("invalid DDP type %d on socket 6", ddpkt.Proto)
}
}
func (port *EtherTalkPort) handleZIPZIP(ctx context.Context, ddpkt *ddp.ExtPacket) error {
zipkt, err := zip.UnmarshalPacket(ddpkt.Data) zipkt, err := zip.UnmarshalPacket(ddpkt.Data)
if err != nil { if err != nil {
return err return err
@ -124,8 +50,19 @@ func (rtr *Router) HandleZIP(ctx context.Context, srcHWAddr ethernet.Addr, ddpkt
switch zipkt := zipkt.(type) { switch zipkt := zipkt.(type) {
case *zip.QueryPacket: case *zip.QueryPacket:
return port.handleZIPQuery(ctx, ddpkt, zipkt)
case *zip.GetNetInfoPacket:
return port.handleZIPGetNetInfo(ctx, ddpkt, zipkt)
default:
return fmt.Errorf("TODO: handle type %T", zipkt)
}
}
func (port *EtherTalkPort) handleZIPQuery(ctx context.Context, ddpkt *ddp.ExtPacket, zipkt *zip.QueryPacket) error {
log.Printf("ZIP: Got Query for networks %v", zipkt.Networks) log.Printf("ZIP: Got Query for networks %v", zipkt.Networks)
networks := rtr.ZoneTable.Query(zipkt.Networks) networks := port.Router.ZoneTable.Query(zipkt.Networks)
sendReply := func(resp *zip.ReplyPacket) error { sendReply := func(resp *zip.ReplyPacket) error {
respRaw, err := resp.Marshal() respRaw, err := resp.Marshal()
@ -139,14 +76,15 @@ func (rtr *Router) HandleZIP(ctx context.Context, srcHWAddr ethernet.Addr, ddpkt
DstNet: ddpkt.SrcNet, DstNet: ddpkt.SrcNet,
DstNode: ddpkt.SrcNode, DstNode: ddpkt.SrcNode,
DstSocket: ddpkt.SrcSocket, DstSocket: ddpkt.SrcSocket,
SrcNet: rtr.MyDDPAddr.Network, SrcNet: port.MyAddr.Network,
SrcNode: rtr.MyDDPAddr.Node, SrcNode: port.MyAddr.Node,
SrcSocket: 6, SrcSocket: 6,
Proto: ddp.ProtoZIP, Proto: ddp.ProtoZIP,
}, },
Data: respRaw, Data: respRaw,
} }
return rtr.sendEtherTalkDDP(srcHWAddr, outDDP) // Note: AARP can block
return port.Send(ctx, outDDP)
} }
// Inside AppleTalk SE, pp 8-11: // Inside AppleTalk SE, pp 8-11:
@ -216,20 +154,36 @@ func (rtr *Router) HandleZIP(ctx context.Context, srcHWAddr ethernet.Addr, ddpkt
} }
} }
return nil return nil
}
case *zip.GetNetInfoPacket: func (port *EtherTalkPort) handleZIPGetNetInfo(ctx context.Context, ddpkt *ddp.ExtPacket, zipkt *zip.GetNetInfoPacket) error {
log.Printf("ZIP: Got GetNetInfo for zone %q", zipkt.ZoneName) log.Printf("ZIP: Got GetNetInfo for zone %q", zipkt.ZoneName)
// Only running a network with one zone for now. // The request is valid if the zone name is available on this network.
valid := slices.Contains(port.AvailableZones, zipkt.ZoneName)
// The multicast address we return depends on the validity of the zone
// name.
var mcastAddr ethernet.Addr
if valid {
mcastAddr = atalk.MulticastAddr(zipkt.ZoneName)
} else {
mcastAddr = atalk.MulticastAddr(port.DefaultZoneName)
}
resp := &zip.GetNetInfoReplyPacket{ resp := &zip.GetNetInfoReplyPacket{
ZoneInvalid: zipkt.ZoneName != rtr.Config.EtherTalk.ZoneName, ZoneInvalid: valid,
UseBroadcast: false, UseBroadcast: false,
OnlyOneZone: true, OnlyOneZone: len(port.AvailableZones) == 1,
NetStart: rtr.Config.EtherTalk.NetStart, NetStart: port.NetStart,
NetEnd: rtr.Config.EtherTalk.NetEnd, NetEnd: port.NetEnd,
ZoneName: zipkt.ZoneName, // has to match request ZoneName: zipkt.ZoneName, // has to match request
MulticastAddr: atalk.MulticastAddr(rtr.Config.EtherTalk.ZoneName), MulticastAddr: mcastAddr,
DefaultZoneName: rtr.Config.EtherTalk.ZoneName, }
// The default zone name is only returned if the requested zone name is
// invalid.
if !valid {
resp.DefaultZoneName = port.DefaultZoneName
} }
log.Printf("ZIP: Replying with GetNetInfo-Reply: %+v", resp) log.Printf("ZIP: Replying with GetNetInfo-Reply: %+v", resp)
@ -253,33 +207,113 @@ func (rtr *Router) HandleZIP(ctx context.Context, srcHWAddr ethernet.Addr, ddpkt
DstNet: ddpkt.SrcNet, DstNet: ddpkt.SrcNet,
DstNode: ddpkt.SrcNode, DstNode: ddpkt.SrcNode,
DstSocket: ddpkt.SrcSocket, DstSocket: ddpkt.SrcSocket,
SrcNet: rtr.MyDDPAddr.Network, SrcNet: port.MyAddr.Network,
SrcNode: rtr.MyDDPAddr.Node, SrcNode: port.MyAddr.Node,
SrcSocket: 6, SrcSocket: 6,
Proto: ddp.ProtoZIP, Proto: ddp.ProtoZIP,
}, },
Data: respRaw, Data: respRaw,
} }
// If it arrived as a broadcast, send the reply as a broadcast.
if ddpkt.DstNet == 0x0000 { if ddpkt.DstNet == 0x0000 {
outDDP.DstNet = 0x0000 outDDP.DstNet = 0x0000
} }
if ddpkt.DstNode == 0xFF { if ddpkt.DstNode == 0xFF {
outDDP.DstNode = 0xFF outDDP.DstNode = 0xFF
} }
// Note: AARP can block
return port.Send(ctx, outDDP)
}
// If it's a broadcast packet, broadcast it. Otherwise don't func (port *EtherTalkPort) handleZIPATP(ctx context.Context, ddpkt *ddp.ExtPacket) error {
dstEth := ethertalk.AppleTalkBroadcast atpkt, err := atp.UnmarshalPacket(ddpkt.Data)
if outDDP.DstNode != 0xFF { if err != nil {
dstEth = srcHWAddr return err
} }
switch atpkt := atpkt.(type) {
case *atp.TReq:
return port.handleZIPTReq(ctx, ddpkt, atpkt)
return rtr.sendEtherTalkDDP(dstEth, outDDP) case *atp.TResp:
return fmt.Errorf("TODO: support handling ZIP ATP replies?")
default: default:
return fmt.Errorf("TODO: handle type %T", zipkt) return fmt.Errorf("unsupported ATP packet type %T for ZIP", atpkt)
}
default:
return fmt.Errorf("invalid DDP type %d on socket 6", ddpkt.Proto)
} }
} }
func (port *EtherTalkPort) handleZIPTReq(ctx context.Context, ddpkt *ddp.ExtPacket, atpkt *atp.TReq) error {
gzl, err := zip.UnmarshalTReq(atpkt)
if err != nil {
return err
}
if gzl.StartIndex == 0 {
return fmt.Errorf("ZIP ATP: received request with StartIndex = 0 (invalid)")
}
resp := &zip.GetZonesReplyPacket{
TID: gzl.TID,
LastFlag: true,
}
switch gzl.Function {
case zip.FunctionGetZoneList:
resp.Zones = port.Router.ZoneTable.AllNames()
case zip.FunctionGetLocalZones:
resp.Zones = port.AvailableZones
case zip.FunctionGetMyZone:
// Note: This shouldn't happen on extended networks (e.g. EtherTalk)
resp.Zones = []string{port.DefaultZoneName}
}
// Inside AppleTalk SE, pp 8-8
if int(gzl.StartIndex) > len(resp.Zones) {
// "Note: A 0-byte response will be returned by a router if the
// index specified in the request is greater than the index of
// the last zone in the list (and the user bytes field will
// indicate no more zones)."
resp.Zones = nil
} else {
// Trim the zones list
// "zone names in the router are assumed to be numbered starting
// with 1"
// and note we checked for 0 above
resp.Zones = resp.Zones[gzl.StartIndex-1:]
size := 0
for i, z := range resp.Zones {
size += 1 + len(z) // length prefix plus string
if size > atp.MaxDataSize {
resp.LastFlag = false
resp.Zones = resp.Zones[:i]
break
}
}
}
respATP, err := resp.MarshalTResp()
if err != nil {
return err
}
ddpBody, err := respATP.Marshal()
if err != nil {
return err
}
respDDP := &ddp.ExtPacket{
ExtHeader: ddp.ExtHeader{
Size: uint16(len(ddpBody)) + atalk.DDPExtHeaderSize,
Cksum: 0,
DstNet: ddpkt.SrcNet,
DstNode: ddpkt.SrcNode,
DstSocket: ddpkt.SrcSocket,
SrcNet: port.MyAddr.Network,
SrcNode: port.MyAddr.Node,
SrcSocket: 6,
Proto: ddp.ProtoATP,
},
Data: ddpBody,
}
// Note: AARP can block
return port.Send(ctx, respDDP)
}

View file

@ -31,7 +31,7 @@ import (
type Zone struct { type Zone struct {
Network ddp.Network Network ddp.Network
Name string Name string
Local bool LocalPort *EtherTalkPort // nil if remote (local to another router)
LastSeen time.Time LastSeen time.Time
} }
@ -68,20 +68,20 @@ func (zt *ZoneTable) Dump() []Zone {
return zs return zs
} }
func (zt *ZoneTable) Upsert(network ddp.Network, name string, local bool) { func (zt *ZoneTable) Upsert(network ddp.Network, name string, localPort *EtherTalkPort) {
zt.mu.Lock() zt.mu.Lock()
defer zt.mu.Unlock() defer zt.mu.Unlock()
key := zoneKey{network, name} key := zoneKey{network, name}
z := zt.zones[key] z := zt.zones[key]
if z != nil { if z != nil {
z.Local = local z.LocalPort = localPort
z.LastSeen = time.Now() z.LastSeen = time.Now()
return return
} }
zt.zones[key] = &Zone{ zt.zones[key] = &Zone{
Network: network, Network: network,
Name: name, Name: name,
Local: local, LocalPort: localPort,
LastSeen: time.Now(), LastSeen: time.Now(),
} }
} }
@ -116,29 +116,29 @@ func (zt *ZoneTable) LookupName(name string) []*Zone {
return zs return zs
} }
func (zt *ZoneTable) LocalNames() []string { // func (zt *ZoneTable) LocalNames() []string {
zt.mu.Lock() // zt.mu.Lock()
seen := make(map[string]struct{}) // seen := make(map[string]struct{})
zs := make([]string, 0, len(zt.zones)) // zs := make([]string, 0, len(zt.zones))
for _, z := range zt.zones { // for _, z := range zt.zones {
// if time.Since(z.LastSeen) > maxZoneAge { // // if time.Since(z.LastSeen) > maxZoneAge {
// continue // // continue
// } // // }
if !z.Local { // if z.Local != nil {
continue // continue
} // }
if _, s := seen[z.Name]; s { // if _, s := seen[z.Name]; s {
continue // continue
} // }
seen[z.Name] = struct{}{} // seen[z.Name] = struct{}{}
zs = append(zs, z.Name) // zs = append(zs, z.Name)
} // }
zt.mu.Unlock() // zt.mu.Unlock()
sort.Strings(zs) // sort.Strings(zs)
return zs // return zs
} // }
func (zt *ZoneTable) AllNames() []string { func (zt *ZoneTable) AllNames() []string {
zt.mu.Lock() zt.mu.Lock()