feat(ncp): NetWare client attach end-to-end — discovery, bindery, dir services, search, connection info

Chased a real NetWare client (Win3.1 NETX + Win98) through the whole
attach sequence against captures, implementing each stall per mars_nwe:

- Discovery: RIP responder on socket 0x0453 (core/protocol/rip +
  core/service/rip), internal-network identity derived from the MAC,
  router broadcast-accept, SAP advertising the internal address; NCP
  replies sourced from the address the client attached to.
- Attach: Negotiate Buffer Size (0x21), static bindery
  (SUPERVISOR/GUEST/EVERYONE/server) serving 0x35/0x36/0x37, GUEST and
  empty-user logins always granted; login binds the connection to its
  bindery object (id/type/login time).
- Directory/volume services: full 0x16 read family plus create/delete/
  rename/alloc handles, seeded LOGIN dir handle 1 at create-connection,
  volume usage replies (LE u32s), lock family granted unconditionally.
- Search: true NW_FILE_INFO/NW_DIR_INFO entry shapes, encoded high-bit
  wildcards (0xAA='*' 0xBF='?' 0xAE='.'), DOS '?' matches one-or-zero
  chars, FCB base/extension matching; Alloc Dir Handle length-prefixed
  path layout (empty = source handle's dir).
- Connection info (Win98 login blocker): Get Connection Information
  (0x17/0x16 old, 0x1C new) — Win9x asks who is logged in on its own
  connection after the login verb and treats 0xFB as not-logged-in —
  plus Get Connection Internet Address (0x13/0x1A) and Get Object
  Connection List (0x15/0x1B; replaces the previous invented 0x15
  shape).
- Logging: always-non-nil injected logger (no call-site guards) in NCP
  and SAP; failed requests log named calls via names.go tables.

Win3.1 confirmed e2e (login, DIR, writes); Win98 connection-info fix
awaiting e2e. Spec: spec/17-ncp.md updated with all wire layouts.
Reference: mars_nwe (nwconn.c, nwbind.c, connect.c) — attributed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: pgodwin

compose/runtime/integration_test.go

@@ -116,7 +116,7 @@ func TestIntegration_NetBEUICallOverInmemLink(t *testing.T) {
 
 	// The real cross-wire: builds the NetBEUI mini-router, attaches the port, and
 	// registers the NBF engine for CLASSICSTACK.
-	crossWireTransports(comps, nil)
+	crossWireTransports(comps, nil, nil)
 
 	ctx := context.Background()
 	if err := comp.Start(ctx); err != nil {
@@ -223,7 +223,7 @@ func TestIntegration_DirectIPXNegotiateOverInmemLink(t *testing.T) {
 		smb.Name:     sm,
 		portipx.Name: comp,
 	}
-	crossWireTransports(comps, nil)
+	crossWireTransports(comps, nil, nil)
 
 	ctx := context.Background()
 	if err := comp.Start(ctx); err != nil {

compose/runtime/runtime.go

@@ -256,7 +256,7 @@ func Build(opts Options) (*Runtime, error) {
 	// service is a no-op. The returned wiring is retained so a port added at RUNTIME
 	// can be attached to its mini-router (SetTransportAttacher, below) and so the
 	// MacIP egress lifecycle can be driven from Start/Stop.
-	transports := crossWireTransports(comps, opts.MacIPEgress)
+	transports := crossWireTransports(comps, opts.MacIPEgress, ctx.Logger)
 
 	// Wire the user store (§4): build the configured store once and hand it to the
 	// supervisor (the web UI's user CRUD surface) AND to every built file service as

compose/runtime/transports.go

@@ -40,9 +40,11 @@ import (
 
 	"github.com/ObsoleteMadness/ClassicStack/core/auth"
 	"github.com/ObsoleteMadness/ClassicStack/core/component"
+	"github.com/ObsoleteMadness/ClassicStack/core/log"
 	diagproto "github.com/ObsoleteMadness/ClassicStack/core/protocol/ipx/diag"
 	ncpproto "github.com/ObsoleteMadness/ClassicStack/core/protocol/ncp"
 	protocol "github.com/ObsoleteMadness/ClassicStack/core/protocol/netbios"
+	ripproto "github.com/ObsoleteMadness/ClassicStack/core/protocol/rip"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/afp"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/browser"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/ipxdiag"
@@ -53,6 +55,7 @@ import (
 	"github.com/ObsoleteMadness/ClassicStack/core/service/nbp"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/ncp"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/netbios"
+	"github.com/ObsoleteMadness/ClassicStack/core/service/rip"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/sap"
 	"github.com/ObsoleteMadness/ClassicStack/core/service/smb"
 )
@@ -107,7 +110,7 @@ func (w *transportWiring) AttachPort(c component.Component) {
 // attach ports added later at runtime (AttachPort). The mini-routers are built whenever
 // their consuming service exists (even with ZERO ports at startup), so the first port of
 // a family added from the config-builder UI has a live router to join.
-func crossWireTransports(comps map[string]component.Component, egressOpener MacIPEgressOpener) *transportWiring {
+func crossWireTransports(comps map[string]component.Component, egressOpener MacIPEgressOpener, mkLogger func(scope string) log.Logger) *transportWiring {
 	nb := netbiosService(comps)
 	sm := smbService(comps)
 	w := &transportWiring{}
@@ -143,7 +146,7 @@ func crossWireTransports(comps map[string]component.Component, egressOpener MacI
 	// by the NetBIOS ipx binding, the direct-hosted leg by the SMB ipx binding.
 	nbIPXBound := nb != nil && nb.Binds(netbios.TransportIPX)
 	smbIPXBound := sm != nil && sm.Binds(smb.TransportIPX)
-	w.ipx = wireIPX(nb, sm, comps, nbIPXBound, smbIPXBound)
+	w.ipx = wireIPX(nb, sm, comps, nbIPXBound, smbIPXBound, mkLogger)
 
 	// The TCP family (direct-hosted SMB over :445; NBT over :139) is a supervised
 	// adapter listener built inert in the registry; wire its SMB consumer + address
@@ -307,7 +310,7 @@ func wireNetBEUI(nb *netbios.Service, comps map[string]component.Component) *net
 // nbIPXBound / smbIPXBound gate the two IPX legs by the operator's transport bindings:
 // the NB-IPX session leg by NetBIOS's ipx binding, the direct-hosted-SMB leg by SMB's
 // ipx binding. A leg whose service is present but whose binding is off is not wired.
-func wireIPX(nb *netbios.Service, sm *smb.Service, comps map[string]component.Component, nbIPXBound, smbIPXBound bool) *ipxrouter.Router {
+func wireIPX(nb *netbios.Service, sm *smb.Service, comps map[string]component.Component, nbIPXBound, smbIPXBound bool, mkLogger func(scope string) log.Logger) *ipxrouter.Router {
 	// Resolve the effective consumers after applying bindings: a service whose ipx
 	// binding is off contributes nothing to the IPX mini-router.
 	if nb != nil && !nbIPXBound {
@@ -353,6 +356,9 @@ func wireIPX(nb *netbios.Service, sm *smb.Service, comps map[string]component.Co
 		if sapAdv == nil {
 			sapAdv = sap.New(r)
 			sapAdv.SetIdentity(r.Network(), r.Node())
+			if mkLogger != nil {
+				sapAdv.SetLogger(mkLogger(sap.Name))
+			}
 		}
 		sapAdv.Register(e)
 	}
@@ -408,11 +414,31 @@ func wireIPX(nb *netbios.Service, sm *smb.Service, comps map[string]component.Co
 	// engine; its SAP entry (File Server 0x0004 @ 0x0451) is registered with the shared
 	// advertiser so NETx/VLM discover it. The transport holds the advertiser handle for
 	// its "sap: advertising" dashboard prop and to stop it on teardown.
+	//
+	// Discovery plumbing (the NetWare client attach sequence, per mars_nwe): the SAP
+	// entry advertises the server at its INTERNAL network address (internal-net:
+	// 00-00-00-00-00-01:0451), never the wire address — the client then broadcasts a
+	// RIP request for that network (GetLocalTarget) and will not open an NCP connection
+	// until it is answered, taking the answer's source MAC as the frame address. So the
+	// mini-router is given the internal identity (it must accept datagrams addressed to
+	// it) and a RIP responder is stood up on socket 0x0453 owning that network.
 	if nc != nil {
+		internalNet := ipxrouter.DeriveInternalNetwork(r.Node())
+		r.SetInternalNetwork(internalNet)
+
 		t := nc.NewOverIPX(r)
 		_ = r.RegisterSocket(ncpproto.NCPSocket, t)
-		sapReg(nc.SAPEntry())
+		e := nc.SAPEntry()
+		e.Network = internalNet
+		e.Node = ipxrouter.InternalNode
+		sapReg(e)
 		t.SetSAP(sapAdv)
+
+		responder := rip.New(r)
+		responder.SetNetworks(internalNet)
+		_ = r.RegisterSocket(ripproto.Socket, responder)
+		responder.Start()
+		t.SetRIP(responder)
 	}
 	// Start the shared advertiser and register it on the SAP socket once any service
 	// registered an entry. (The NB-IPX entry may register later, from the async claim

compose/runtime/transports_test.go

@@ -69,7 +69,7 @@ func TestCrossWireTransports_NetBEUIToSMB(t *testing.T) {
 		browser.Name: br,
 	}
 
-	crossWireTransports(comps, nil)
+	crossWireTransports(comps, nil, nil)
 
 	// AddPort must have installed the inbound delivery callback on the port.
 	if port.cb == nil {
@@ -142,7 +142,7 @@ func TestCrossWireTransports_DirectIPXWithoutNetBIOS(t *testing.T) {
 		"IPX":    port,
 	}
 
-	crossWireTransports(comps, nil)
+	crossWireTransports(comps, nil, nil)
 
 	if port.cb == nil {
 		t.Fatal("direct-IPX without NetBIOS did not attach the IPX port (no delivery callback) — the mini-router was not built off the SMB consumer")
@@ -165,7 +165,7 @@ func TestTransportWiring_AttachPortNetBEUILate(t *testing.T) {
 		netbios.Name: nb,
 		smb.Name:     sm,
 	}
-	w := crossWireTransports(comps, nil)
+	w := crossWireTransports(comps, nil, nil)
 	if w.netbeui == nil {
 		t.Fatal("NetBEUI mini-router was not built with zero ports — a late port would have nowhere to attach")
 	}
@@ -200,7 +200,7 @@ func TestTransportWiring_AttachPortIPXLate(t *testing.T) {
 	sm := smb.New(nil)
 	comps := map[string]component.Component{smb.Name: sm}
 
-	w := crossWireTransports(comps, nil)
+	w := crossWireTransports(comps, nil, nil)
 	if w.ipx == nil {
 		t.Fatal("IPX mini-router was not built off the SMB consumer with zero ports")
 	}
@@ -216,7 +216,7 @@ func TestTransportWiring_AttachPortIPXLate(t *testing.T) {
 // transport was wired (no NetBIOS/SMB consumer): the wiring holds nil mini-routers, so a
 // late port is simply left alone rather than attached to a phantom router.
 func TestTransportWiring_AttachPortNoRouters(t *testing.T) {
-	w := crossWireTransports(map[string]component.Component{}, nil)
+	w := crossWireTransports(map[string]component.Component{}, nil, nil)
 	if w.ipx != nil || w.netbeui != nil {
 		t.Fatal("mini-routers built with no consumer to drive them")
 	}
@@ -261,7 +261,7 @@ func TestCrossWireTransports_NoNetBIOS(t *testing.T) {
 	port := &recordingNetBEUIPort{}
 	comps := map[string]component.Component{"NetBEUI": port}
 
-	crossWireTransports(comps, nil)
+	crossWireTransports(comps, nil, nil)
 
 	if port.cb != nil {
 		t.Fatal("cross-wire attached a NetBEUI port with no NetBIOS service to feed")

core/protocol/ncp/ncp.go

@@ -44,14 +44,17 @@ const (
 const (
 	CompletionSuccess       uint8 = 0x00 // operation succeeded
 	CompletionConnNotLogged uint8 = 0x7C // connection not logged in
-	CompletionNoSuchObject  uint8 = 0x96 // bindery object not found
-	CompletionInvalidConn   uint8 = 0x9B // bad connection number / station
+	CompletionNoSuchObject  uint8 = 0xFC // bindery: no such object (mars_nwe -0xfc)
+	CompletionNoSuchVolume  uint8 = 0x98 // volume does not exist (mars_nwe -0x98)
+	CompletionInvalidConn   uint8 = 0x9B // bad connection number / station / dir handle
+	CompletionBadStation    uint8 = 0xFD // bad station (target connection) number (mars_nwe 0xfd)
 	CompletionNoFiles       uint8 = 0x9C // no more matching files (scan end)
 	CompletionInvalidPath   uint8 = 0x9C // invalid path (shares 0x9C in NetWare)
 	CompletionNoSuchFile    uint8 = 0xFF // file/dir not found (generic failure)
 	CompletionFuncNotSupp   uint8 = 0xFB // requested function not supported
 	CompletionLockFail      uint8 = 0xFE // lock / busy
 	CompletionAccessDenied  uint8 = 0x8C // no privileges / access denied
+	CompletionBadNameSpace  uint8 = 0xBF // invalid name space (mars_nwe's AFP-calls reply)
 )
 
 // Connection-status bits (the reply header's ConnectionStatus byte). Bit 0x40

core/protocol/rip/rip.go

@@ -0,0 +1,91 @@
+// Package rip holds the Novell IPX Routing Information Protocol wire DTOs — the
+// request/response format riding IPX socket 0x0453 (IPX packet type 1). A NetWare
+// client resolves the network a SAP advertisement names via a RIP Request (the
+// "GetLocalTarget" step) before it will open an NCP connection: it broadcasts a
+// Request for the advertised network and takes the responder's node as the
+// immediate (MAC-level) address for that network.
+//
+// Wire format (all fields BIG-ENDIAN): a 2-byte operation followed by zero or more
+// 8-byte entries — network(4) hops(2) ticks(2). In a Request the hops/ticks of each
+// entry are 0xFFFF filler; the network 0xFFFFFFFF asks for all known routes.
+//
+// Reference: Novell RIP (IPX socket 0x0453); mars_nwe nwroute.c (handle_rip,
+// build_rip_buff, send_rip_buff) — the canonical open-source reference (CLAUDE.md #7).
+package rip
+
+import "errors"
+
+// Socket is the well-known IPX socket RIP rides.
+var Socket = [2]byte{0x04, 0x53}
+
+// IPXType is the IPX packet type for RIP (type 1).
+const IPXType uint8 = 0x01
+
+// RIP operation codes (the first two bytes of a RIP packet, big-endian).
+const (
+	OpRequest  uint16 = 0x0001 // route query ("GetLocalTarget" when for one net)
+	OpResponse uint16 = 0x0002 // answer to a request / periodic broadcast
+)
+
+// NetworkWildcard in a Request entry asks for all known routes (mars_nwe MAX_U32).
+var NetworkWildcard = [4]byte{0xFF, 0xFF, 0xFF, 0xFF}
+
+// HopsUnreachable marks a route as down (16 = infinity). A shutdown broadcast
+// advertises every owned network at this metric so clients drop the route
+// (mars_nwe send_rip_broadcast mode 2 → hops 16).
+const HopsUnreachable uint16 = 16
+
+// EntryLen is the fixed length of one RIP entry: network(4) hops(2) ticks(2).
+const EntryLen = 8
+
+// headerLen is the operation field ahead of the entries.
+const headerLen = 2
+
+// ErrShort is returned by Unmarshal for a buffer too short to hold an operation.
+var ErrShort = errors.New("rip: packet shorter than operation header")
+
+// Entry is one route: the network and its distance in router hops and ticks
+// (1 tick ≈ 1/18.2 s). A directly served network is hops 1 / ticks 2 in a
+// response (mars_nwe ins_rip_buff(internal_net, 1, 2); a real NetWare 4 server
+// answers the same).
+type Entry struct {
+	Network [4]byte
+	Hops    uint16
+	Ticks   uint16
+}
+
+// Packet is a parsed RIP request or response.
+type Packet struct {
+	Operation uint16
+	Entries   []Entry
+}
+
+// Marshal appends the wire form (operation + entries) to dst and returns it.
+func (p *Packet) Marshal(dst []byte) []byte {
+	dst = append(dst, byte(p.Operation>>8), byte(p.Operation))
+	for _, e := range p.Entries {
+		dst = append(dst, e.Network[:]...)
+		dst = append(dst, byte(e.Hops>>8), byte(e.Hops))
+		dst = append(dst, byte(e.Ticks>>8), byte(e.Ticks))
+	}
+	return dst
+}
+
+// Unmarshal parses a RIP packet. Trailing bytes short of a whole entry are
+// ignored (clients pad to minimum Ethernet frame length).
+func Unmarshal(b []byte) (*Packet, error) {
+	if len(b) < headerLen {
+		return nil, ErrShort
+	}
+	p := &Packet{Operation: uint16(b[0])<<8 | uint16(b[1])}
+	b = b[headerLen:]
+	for len(b) >= EntryLen {
+		var e Entry
+		copy(e.Network[:], b[:4])
+		e.Hops = uint16(b[4])<<8 | uint16(b[5])
+		e.Ticks = uint16(b[6])<<8 | uint16(b[7])
+		p.Entries = append(p.Entries, e)
+		b = b[EntryLen:]
+	}
+	return p, nil
+}

core/router/ipx/ipx.go

@@ -26,6 +26,25 @@ import (
 // NetBIOS-over-IPX name claims.
 var BroadcastNode = [6]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
 
+// InternalNode is the node ID of the server on its internal network. NetWare's internal
+// network always hosts the server at node 00-00-00-00-00-01 (mars_nwe nwserv.c: node
+// defaults to 1; a real NetWare 4 server advertises the same). SAP advertises the NCP
+// file service at internal-net:InternalNode:0x0451.
+var InternalNode = [6]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x01}
+
+// DeriveInternalNetwork returns the default NetWare internal network number for a
+// station: the low four bytes of its node ID. The internal network must be nonzero
+// and unique on the internetwork; deriving it from the (unique) hardware address is
+// the same spirit as mars_nwe's AUTO mode, which derives it from the host's IP
+// address. A node whose low bytes are all zero falls back to a fixed nonzero number.
+func DeriveInternalNetwork(node [6]byte) [4]byte {
+	net := [4]byte{node[2], node[3], node[4], node[5]}
+	if net == ([4]byte{}) {
+		return [4]byte{0x00, 0x00, 0x00, 0x01}
+	}
+	return net
+}
+
 // DefaultNetwork is the fall-back IPX network number when the operator has not configured one.
 // All-zeros ("local segment, unknown") matches what Win98/NWLink uses before a NetWare server
 // assigns a real number, so ClassicStack and its clients appear on the same segment.
@@ -55,14 +74,15 @@ type NodeHandler interface {
 // Router dispatches inbound IPX datagrams to socket/node/broadcast handlers and fills source
 // addresses on outbound datagrams. Implementations are safe for concurrent use.
 type Router struct {
-	logger    log.Logger
-	mu        sync.RWMutex
-	network   [4]byte
-	node      [6]byte
-	sockets   map[[2]byte]SocketHandler
-	nodes     map[[6]byte]NodeHandler
-	broadcast NodeHandler
-	ports     []Port
+	logger      log.Logger
+	mu          sync.RWMutex
+	network     [4]byte
+	node        [6]byte
+	internalNet [4]byte // NetWare internal network (zero = none); see SetInternalIdentity
+	sockets     map[[2]byte]SocketHandler
+	nodes       map[[6]byte]NodeHandler
+	broadcast   NodeHandler
+	ports       []Port
 }
 
 // NewRouter returns a router with the default network number and a zero node ID. Callers
@@ -98,6 +118,24 @@ func (r *Router) Node() [6]byte {
 	return r.node
 }
 
+// SetInternalNetwork configures the NetWare internal network number. The server is
+// addressable on it as internal-net:InternalNode (the NCP file service's advertised
+// address, mars_nwe's my_server_adr): inbound datagrams so addressed pass the
+// destination filter and dispatch by socket as usual. Zero disables the internal
+// network (the default).
+func (r *Router) SetInternalNetwork(network [4]byte) {
+	r.mu.Lock()
+	r.internalNet = network
+	r.mu.Unlock()
+}
+
+// InternalNetwork returns the configured NetWare internal network number (zero = none).
+func (r *Router) InternalNetwork() [4]byte {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.internalNet
+}
+
 // RegisterSocket attaches handler to inbound datagrams whose destination socket matches.
 func (r *Router) RegisterSocket(socket [2]byte, handler SocketHandler) error {
 	r.mu.Lock()
@@ -208,21 +246,29 @@ func (r *Router) Inbound(d *protocol.Datagram) {
 }
 
 // acceptsDest reports whether (network, node) matches the router's identity or is a broadcast.
-// Network 0 ("local segment, unknown") is accepted because some clients send name-claim
-// broadcasts that way before learning the network number.
+// Broadcast-node datagrams are accepted regardless of destination network: we serve every
+// segment the port hears, and a client that has learned a real wire network number (e.g. from
+// a coexisting NetWare server's RIP/SAP) addresses its broadcasts to that net — a SAP
+// GetNearestServer so addressed must still reach the advertiser. For unicast, network 0
+// ("local segment, unknown") is accepted alongside our own network, and the NetWare internal
+// address (internal-net:InternalNode) is accepted when an internal network is configured.
 func (r *Router) acceptsDest(network [4]byte, node [6]byte) bool {
 	r.mu.RLock()
 	ours := r.network
 	myNode := r.node
+	internal := r.internalNet
 	_, claimed := r.nodes[node]
 	r.mu.RUnlock()
 
-	if !isZero4(network) && network != ours {
-		return false
-	}
 	if node == BroadcastNode {
 		return true
 	}
+	if !isZero4(internal) && network == internal && node == InternalNode {
+		return true
+	}
+	if !isZero4(network) && network != ours {
+		return false
+	}
 	return node == myNode || claimed
 }