refactor(driver/ipc): replace reqID multiplexer with channel-based serial semaphore

Prior design kept a map[uint64]chan of in-flight requests, which let
concurrent goroutines race and interleave responses. Replace with a
single waitSem (capacity-1 channel) that serialises request/reply pairs
while keeping push frames (cmdRecv, cmdAccept, cmdCloseOK) routed
through per-connection channels concurrently.

Key changes:
- Drop 8-byte reqID from envelope header (ipcEnvelopeHeaderSize: 9→1)
- ipcClient.pending is now a chan *pendingResponse (capacity 16) instead
  of a map; readLoop writes known response cmds directly, sendAndWait reads
- doneCh close wakes goroutines blocked on waitSem to prevent deadlock
  when daemon disconnects while many goroutines are queued
- Disconnect() becomes fire-and-forget (send, not sendAndWait) since
  the daemon never replies to cmdClose in a way sendAndWait can safely demux
- cmdCancel removed (no longer needed; timeout races are handled by timer
  beating doneCh before semaphore is acquired)

Author: teovl

pkg/daemon/zz_ipc_bind_accept_test.go

@@ -131,32 +131,31 @@ func TestHandleBindPortAlreadyBoundReturnsError(t *testing.T) {
 	assertErrorReply(t, reply, "already bound")
 }
 
-// --- handleSend: missing connID (len < 4) emits CmdError ---
+// --- handleSend: fire-and-forget — no reply on error ---
 
 func TestHandleSendShortPayloadEmitsError(t *testing.T) {
 	t.Parallel()
 	d := New(Config{})
 	s := d.ipc
 
 	ic, client := newIPCTestConn(t)
-	reply := runHandler(t, client, func() {
-		s.handleSend(ic, 0, []byte{0x01, 0x02}) // only 2 bytes — need ≥4
-	})
-	assertErrorReply(t, reply, "send: missing conn_id")
+	done := make(chan struct{})
+	go func() { s.handleSend(ic, 0, []byte{0x01, 0x02}); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
-// --- handleSend: unknown connID emits CmdError("connection N not found") ---
-
 func TestHandleSendUnknownConnIDEmitsError(t *testing.T) {
 	t.Parallel()
 	d := New(Config{})
 	s := d.ipc
 
 	ic, client := newIPCTestConn(t)
-	// Valid 4-byte connID followed by payload; conn doesn't exist.
 	payload := []byte{0x00, 0x00, 0xFF, 0xFE, 'x'}
-	reply := runHandler(t, client, func() { s.handleSend(ic, 0, payload) })
-	assertErrorReply(t, reply, "connection 65534 not found")
+	done := make(chan struct{})
+	go func() { s.handleSend(ic, 0, payload); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
 // --- handleClose: unknown connID still writes CmdCloseOK (no error path) ---

pkg/daemon/zz_ipc_socket_lifecycle_test.go

@@ -238,10 +238,10 @@ func TestIPCServerHandleClientEmptyFrameContinuesLoop(t *testing.T) {
 	}
 	defer conn.Close()
 
-	// Send a frame too short for the envelope header (issue #99 wire
-	// format), then a valid CmdBind. If the continue branch works, the
-	// second frame still produces a CmdBindOK.
-	if err := ipcutil.Write(conn, []byte{0x01, 0x02}); err != nil {
+	// Send an empty frame (0 bytes — shorter than the 1-byte header),
+	// then a valid CmdBind. If the continue branch works, the second
+	// frame still produces a CmdBindOK.
+	if err := ipcutil.Write(conn, []byte{}); err != nil {
 		t.Fatalf("write short frame: %v", err)
 	}
 	if err := writeIPCRequest(conn, CmdBind, []byte{0x20, 0x01}); err != nil {

pkg/daemon/zz_ipc_test.go

@@ -168,26 +168,40 @@ func TestHandleDialPortDeniedByPolicySendsError(t *testing.T) {
 	assertErrorReply(t, reply, "not allowed")
 }
 
+// assertNoReply verifies that no IPC frame is written within a short window.
+// handleSend and handleSendTo are fire-and-forget: they never write a reply.
+func assertNoReply(t *testing.T, client net.Conn) {
+	t.Helper()
+	_ = client.SetReadDeadline(time.Now().Add(50 * time.Millisecond))
+	_, err := ipcutil.Read(client)
+	if err == nil {
+		t.Fatal("handler unexpectedly sent a reply")
+	}
+}
+
 // --- handleSend ---
 
 func TestHandleSendShortPayloadSendsError(t *testing.T) {
 	t.Parallel()
 	d := New(Config{})
 	s := d.ipc
 	ic, client := newIPCTestConn(t)
-	reply := runHandler(t, client, func() { s.handleSend(ic, 0, []byte{0x01}) }) // <4 bytes
-	assertErrorReply(t, reply, "send: missing conn_id")
+	done := make(chan struct{})
+	go func() { s.handleSend(ic, 0, []byte{0x01}); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
 func TestHandleSendUnknownConnIDSendsError(t *testing.T) {
 	t.Parallel()
 	d := New(Config{})
 	s := d.ipc
 	ic, client := newIPCTestConn(t)
-	// 4-byte conn_id that doesn't exist + some payload.
 	payload := []byte{0x00, 0x00, 0x00, 0x7B, 'a', 'b', 'c'} // conn_id 123
-	reply := runHandler(t, client, func() { s.handleSend(ic, 0, payload) })
-	assertErrorReply(t, reply, "connection 123 not found")
+	done := make(chan struct{})
+	go func() { s.handleSend(ic, 0, payload); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
 // --- handleClose ---
@@ -227,8 +241,10 @@ func TestHandleSendToShortPayloadSendsError(t *testing.T) {
 	d := New(Config{})
 	s := d.ipc
 	ic, client := newIPCTestConn(t)
-	reply := runHandler(t, client, func() { s.handleSendTo(ic, 0, []byte{0x00}) })
-	assertErrorReply(t, reply, "sendto: missing address/port")
+	done := make(chan struct{})
+	go func() { s.handleSendTo(ic, 0, []byte{0x00}); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
 func TestHandleSendToBroadcastOnNetworkZeroSendsError(t *testing.T) {
@@ -244,8 +260,10 @@ func TestHandleSendToBroadcastOnNetworkZeroSendsError(t *testing.T) {
 	binary.BigEndian.PutUint16(payload[protocol.AddrSize:], 80)
 	copy(payload[protocol.AddrSize+2:], "data")
 
-	reply := runHandler(t, client, func() { s.handleSendTo(ic, 0, payload) })
-	assertErrorReply(t, reply, "sendto:")
+	done := make(chan struct{})
+	go func() { s.handleSendTo(ic, 0, payload); close(done) }()
+	assertNoReply(t, client) // fire-and-forget: no reply on error
+	<-done
 }
 
 // --- handleInfo ---

pkg/driver/driver.go

@@ -325,12 +325,15 @@ func (d *Driver) RotateKey() (map[string]interface{}, error) {
 }
 
 // Disconnect closes a connection by ID. Used by administrative tools.
+// Fire-and-forget: the daemon always responds CmdCloseOK regardless of
+// whether the connID exists, so there is no error to propagate. Using
+// sendAndWait here would corrupt a concurrent sendAndWait for a different
+// command if a server-pushed cmdCloseOK (remote FIN) arrived simultaneously.
 func (d *Driver) Disconnect(connID uint32) error {
 	msg := make([]byte, 5)
 	msg[0] = cmdClose
 	binary.BigEndian.PutUint32(msg[1:5], connID)
-	_, err := d.ipc.sendAndWait(msg, cmdCloseOK)
-	return err
+	return d.ipc.send(msg)
 }
 
 // NetworkList returns all networks known to the registry.