continue reworking StackNode implementations

internet/definitions.go

@@ -52,10 +52,10 @@ var (
 )
 
 func handleNodeError(nodesPtr *[]node, nodeIdx int, err error) {
-	if nodeIdx >= len(*nodesPtr) {
-		panic("unreachable")
-	}
 	if err != nil {
+		if nodeIdx >= len(*nodesPtr) {
+			panic("unreachable")
+		}
 		nodes := *nodesPtr
 		badConnID := nodes[nodeIdx].connID != nil && *nodes[nodeIdx].connID != nodes[nodeIdx].currConnID
 		if err == net.ErrClosed || nodes[nodeIdx].lastErrs[0] == err || nodes[nodeIdx].lastErrs[1] == err || badConnID {

internet/endpoint-arp.go

@@ -1,4 +0,0 @@
-package internet
-
-type ARPEndpoint struct {
-}

internet/node-arp.go

@@ -0,0 +1,51 @@
+package internet
+
+import (
+	"log/slog"
+
+	"github.com/soypat/lneto"
+	"github.com/soypat/lneto/arp"
+	"github.com/soypat/lneto/ethernet"
+)
+
+type NodeARP struct {
+	handler arp.Handler
+	vld     lneto.Validator
+}
+
+func (narp *NodeARP) Reset(cfg arp.HandlerConfig) error {
+	return narp.handler.Reset(cfg)
+}
+
+func (narp *NodeARP) LocalPort() uint16 { return 0 }
+
+func (narp *NodeARP) Protocol() uint64 { return uint64(ethernet.TypeARP) }
+
+func (narp *NodeARP) ConnectionID() *uint64 { return narp.handler.ConnectionID() }
+
+func (narp *NodeARP) Demux(EtherFrame []byte, arpOff int) error {
+	afrm, err := arp.NewFrame(EtherFrame[arpOff:])
+	if err != nil {
+		slog.Error("bad-ARP", slog.String("err", err.Error()))
+		return nil
+	}
+	afrm.ValidateSize(&narp.vld)
+	if narp.vld.HasError() {
+		slog.Error("invalid-ARP", slog.String("err", narp.vld.Err().Error()))
+		return nil
+	}
+	return narp.handler.Recv(EtherFrame[arpOff:])
+}
+
+func (narp *NodeARP) Encapsulate(EtherFrame []byte, arpOff int) (int, error) {
+	n, err := narp.handler.Send(EtherFrame[arpOff:])
+	if err != nil || n == 0 {
+		return 0, err // end with error.
+	}
+	afrm, _ := arp.NewFrame(EtherFrame[arpOff:])
+	hwaddr, _ := afrm.Target()
+	efrm, _ := ethernet.NewFrame(EtherFrame)
+	copy(efrm.DestinationHardwareAddr()[:], hwaddr)
+	slog.Info("handle", slog.String("out", afrm.String()))
+	return n, err
+}

internet/stack-ip.go

@@ -152,18 +152,14 @@ func (sb *StackIP) Encapsulate(carrierData []byte, frameOffset int) (int, error)
 }
 
 func (sb *StackIP) Register(h StackNode) error {
-	port := h.LocalPort()
 	proto := h.Protocol()
-	if port <= 0 {
-		return errZeroPort
-	} else if proto > 255 {
+	if proto > 255 {
 		return errInvalidProto
 	}
 	sb.handlers = append(sb.handlers, node{
 		demux:       h.Demux,
 		encapsulate: h.Encapsulate,
 		proto:       uint16(proto),
-		port:        port,
 	})
 	return nil
 }
@@ -173,8 +169,8 @@ func (sb *StackIP) RegisterTCPConn(conn *TCPConn) error {
 		return errZeroPort
 	}
 	sb.handlers = append(sb.handlers, node{
-		demux:       conn.RecvIP,
-		encapsulate: conn.HandleIP,
+		demux:       conn.Demux,
+		encapsulate: conn.Encapsulate,
 		proto:       uint16(lneto.IPProtoTCP),
 		port:        conn.LocalPort(),
 	})

internet/stack-linklayer.go

@@ -35,6 +35,8 @@ func (ls *StackLinkLayer) Reset6(mac, gateway [6]byte, mtu int) error {
 	return nil
 }
 
+func (ls *StackLinkLayer) MTU() int { return int(ls.mtu) }
+
 func (ls *StackLinkLayer) ConnectionID() *uint64 { return &ls.connID }
 
 func (ls *StackLinkLayer) LocalPort() uint16 { return 0 }

internet/stack-port.go

@@ -5,28 +5,28 @@ import (
 	"io"
 )
 
-type StackPort struct {
+type StackPorts struct {
 	connID     uint64
 	protocol   uint64
 	handlers   []node
 	dstPortOff int
 }
 
-func (ps *StackPort) Reset(protocol uint64, dstPortOffset int) {
-	*ps = StackPort{
+func (ps *StackPorts) Reset(protocol uint64, dstPortOffset int) {
+	*ps = StackPorts{
 		connID:     ps.connID + 1,
 		handlers:   ps.handlers[:0],
 		dstPortOff: dstPortOffset,
 		protocol:   protocol,
 	}
 }
-func (ps *StackPort) LocalPort() uint16 { return 0 }
+func (ps *StackPorts) LocalPort() uint16 { return 0 }
 
-func (ps *StackPort) Protocol() uint64 { return ps.protocol }
+func (ps *StackPorts) Protocol() uint64 { return ps.protocol }
 
-func (ps *StackPort) ConnectionID() *uint64 { return &ps.connID }
+func (ps *StackPorts) ConnectionID() *uint64 { return &ps.connID }
 
-func (ps *StackPort) Encapsulate(b []byte, offset int) (n int, err error) {
+func (ps *StackPorts) Encapsulate(b []byte, offset int) (n int, err error) {
 	if ps.dstPortOff+offset+2 > len(b) {
 		return 0, io.ErrShortBuffer
 	}
@@ -41,7 +41,7 @@ func (ps *StackPort) Encapsulate(b []byte, offset int) (n int, err error) {
 	return n, err
 }
 
-func (ps *StackPort) Demux(b []byte, offset int) (err error) {
+func (ps *StackPorts) Demux(b []byte, offset int) (err error) {
 	if ps.dstPortOff+offset+2 > len(b) {
 		return io.ErrShortBuffer
 	}
@@ -60,7 +60,7 @@ func (ps *StackPort) Demux(b []byte, offset int) (err error) {
 	return err
 }
 
-func (ps *StackPort) Register(h StackNode) error {
+func (ps *StackPorts) Register(h StackNode) error {
 	port := h.LocalPort()
 	proto := h.Protocol()
 	if port <= 0 {
@@ -76,6 +76,6 @@ func (ps *StackPort) Register(h StackNode) error {
 	return nil
 }
 
-func (ps *StackPort) handleResult(handlerIdx, n int, err error) {
+func (ps *StackPorts) handleResult(handlerIdx, n int, err error) {
 	handleNodeError(&ps.handlers, handlerIdx, err)
 }

internet/tcpconn.go

@@ -98,7 +98,7 @@ func (conn *TCPConn) Close() error {
 	return conn.h.Close()
 }
 
-func (conn *TCPConn) RecvIP(buf []byte, off int) (err error) {
+func (conn *TCPConn) Demux(buf []byte, off int) (err error) {
 	conn.trace("tcpconn.Recv:start")
 	if off >= len(buf) {
 		return errors.New("bad offset in TCPConn.Recv")
@@ -198,7 +198,7 @@ func (conn *TCPConn) checkPipeOpen() error {
 	return nil
 }
 
-func (conn *TCPConn) HandleIP(buf []byte, off int) (n int, err error) {
+func (conn *TCPConn) Encapsulate(buf []byte, off int) (n int, err error) {
 	if len(conn.remoteAddr) == 0 {
 		return 0, errors.New("unset IP address")
 	}