starpc 0.52.0 → 0.52.2

package/srpc/mux.rs

@@ -90,9 +90,7 @@ impl Mux {
         let method_ids = handler.method_ids();
 
         let mut services = self.services.write().unwrap();
-        let service_methods = services
-            .entry(service_id.to_string())
-            .or_insert_with(HashMap::new);
+        let service_methods = services.entry(service_id.to_string()).or_default();
 
         for method_id in method_ids {
             if !method_id.is_empty() {
@@ -346,7 +344,9 @@ mod tests {
         }
 
         // Should find the method even with empty service ID
-        let (handled, result) = mux.invoke_method("", "TestMethod", Box::new(MockStream)).await;
+        let (handled, result) = mux
+            .invoke_method("", "TestMethod", Box::new(MockStream))
+            .await;
         assert!(handled);
         assert!(result.is_ok());
     }

package/srpc/net.go

@@ -7,12 +7,14 @@ import (
 
 // Dial dials a remote server using TCP with the default muxed conn type.
 func Dial(addr string) (Client, error) {
+	// Connect the byte stream before attaching its stream multiplexer.
 	nconn, err := net.Dial("tcp", addr)
 	if err != nil {
 		return nil, err
 	}
 	muxedConn, err := NewMuxedConn(nconn, false, nil)
 	if err != nil {
+		_ = nconn.Close()
 		return nil, err
 	}
 	return NewClientWithMuxedConn(muxedConn), nil
@@ -22,11 +24,14 @@ func Dial(addr string) (Client, error) {
 // Returns on any fatal error or if ctx was canceled.
 // errCh is an optional error channel (can be nil)
 func Listen(ctx context.Context, addr string, srv *Server, errCh <-chan error) error {
+	// The listener and its accept routine live until this function returns.
 	lis, err := net.Listen("tcp", addr)
 	if err != nil {
 		return err
 	}
+	defer lis.Close()
 
+	// Observe serving failure alongside the caller's stop conditions.
 	listenErrCh := make(chan error, 1)
 	go func() {
 		listenErrCh <- AcceptMuxedListener(ctx, lis, srv, nil)
@@ -35,10 +40,14 @@ func Listen(ctx context.Context, addr string, srv *Server, errCh <-chan error) e
 
 	select {
 	case <-ctx.Done():
-		return context.Canceled
-	case err := <-errCh:
-		return err
+		err = ctx.Err()
+	case err = <-errCh:
 	case err := <-listenErrCh:
 		return err
 	}
+
+	// Closing the listener wakes Accept; wait for its cleanup before returning.
+	_ = lis.Close()
+	<-listenErrCh
+	return err
 }

package/srpc/packet-codec-vectors_test.go

@@ -0,0 +1,195 @@
+package srpc
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"testing"
+)
+
+type packetCodecVector struct {
+	Name      string `json:"name"`
+	PacketHex string `json:"packet_hex"`
+	FrameHex  string `json:"frame_hex"`
+}
+
+func TestPacketCodecGoldenVectors(t *testing.T) {
+	data, err := os.ReadFile("../testdata/packet-codec-vectors.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var document struct {
+		Cases []packetCodecVector `json:"cases"`
+	}
+	if err := json.Unmarshal(data, &document); err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range document.Cases {
+		if tc.PacketHex == "" || tc.FrameHex == "" {
+			continue
+		}
+		t.Run(tc.Name, func(t *testing.T) {
+			packet := goldenPacket(t, tc.Name)
+			packetData, err := packet.MarshalVT()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.PacketHex); !bytes.Equal(packetData, want) {
+				t.Fatalf("packet = %x, want %x", packetData, want)
+			}
+			stream := &packetTestStream{}
+			if err := NewPacketReadWriter(stream).WritePacket(packet); err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.FrameHex); !bytes.Equal(stream.writes, want) {
+				t.Fatalf("frame = %x, want %x", stream.writes, want)
+			}
+		})
+	}
+}
+
+func goldenPacket(t *testing.T, name string) *Packet {
+	t.Helper()
+	switch name {
+	case "call_start_data":
+		return NewCallStartPacket("svc", "method", []byte("abc"), false)
+	case "call_start_absent_empty":
+		return NewCallStartPacket("svc", "method", nil, false)
+	case "call_start_present_empty":
+		return NewCallStartPacket("svc", "method", nil, true)
+	case "call_data_terminal":
+		return NewCallDataPacket([]byte("out"), false, true, nil)
+	case "call_data_error":
+		return NewCallDataPacket(nil, false, false, errors.New("failed"))
+	case "call_cancel":
+		return NewCallCancelPacket()
+	default:
+		t.Fatalf("unknown golden packet %q", name)
+		return nil
+	}
+}
+
+func decodeHex(t *testing.T, value string) []byte {
+	t.Helper()
+	data, err := hex.DecodeString(value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data
+}
+
+func framePacket(t *testing.T, packet *Packet) []byte {
+	t.Helper()
+	packetSize := packet.SizeVT()
+	if packetSize > maxMessageSize {
+		t.Fatalf("packet size %d exceeds maximum %d", packetSize, maxMessageSize)
+	}
+	frame := make([]byte, 4+packetSize)
+	binary.LittleEndian.PutUint32(frame, uint32(packetSize)) //nolint:gosec // bounded by maxMessageSize
+	if _, err := packet.MarshalToSizedBufferVT(frame[4:]); err != nil {
+		t.Fatal(err)
+	}
+	return frame
+}
+
+type packetTestStream struct {
+	reads   bytes.Buffer
+	writes  []byte
+	maxRead int
+}
+
+func (s *packetTestStream) Read(data []byte) (int, error) {
+	if s.maxRead > 0 && len(data) > s.maxRead {
+		data = data[:s.maxRead]
+	}
+	return s.reads.Read(data)
+}
+
+func (s *packetTestStream) Write(data []byte) (int, error) {
+	s.writes = append(s.writes, data...)
+	return len(data), nil
+}
+
+func (s *packetTestStream) Close() error { return nil }
+
+func TestPacketCodecReadFragmentsAndCoalesces(t *testing.T) {
+	first := framePacket(t, NewCallCancelPacket())
+	second := framePacket(t, NewCallDataPacket([]byte("x"), false, true, nil))
+	input := append(first, second...)
+	stream := &packetTestStream{reads: *bytes.NewBuffer(input)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+		count++
+		return decode(data)
+	})
+	if err != nil || count != 2 {
+		t.Fatalf("ReadToHandler() = %v, packets=%d", err, count)
+	}
+}
+
+func TestPacketCodecReadEveryFragmentBoundary(t *testing.T) {
+	frame := framePacket(t, NewCallCancelPacket())
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	for size := 1; size <= len(frame); size++ {
+		stream := &packetTestStream{reads: *bytes.NewBuffer(frame), maxRead: size}
+		var count int
+		err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+			count++
+			return decode(data)
+		})
+		if err != nil || count != 1 {
+			t.Fatalf("chunk %d: err=%v count=%d", size, err, count)
+		}
+	}
+}
+
+func TestPacketCodecRejectsInvalidPrefixesAndMalformedPacket(t *testing.T) {
+	for name, frame := range map[string][]byte{
+		"zero":      {0, 0, 0, 0},
+		"oversized": {0x81, 0x96, 0x98, 0x00},
+	} {
+		t.Run(name, func(t *testing.T) {
+			stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+			if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err == nil {
+				t.Fatal("accepted invalid prefix")
+			}
+		})
+	}
+	frame := []byte{3, 0, 0, 0, 0x0a, 0x01, 0xff}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	if err := NewPacketReadWriter(stream).ReadToHandler(decode); err == nil {
+		t.Fatal("accepted malformed protobuf")
+	}
+}
+
+func TestPacketCodecCleanEOFReturnsNil(t *testing.T) {
+	stream := &packetTestStream{reads: *bytes.NewBuffer(nil)}
+	if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err != nil {
+		t.Fatalf("clean EOF: %v", err)
+	}
+}
+
+func TestPacketCodecTruncatedBodyAtEOF(t *testing.T) {
+	frame := []byte{4, 0, 0, 0, 0x0a, 0x01}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error {
+		count++
+		return nil
+	})
+	if err != io.ErrUnexpectedEOF || count != 0 {
+		t.Fatalf("err=%v count=%d", err, count)
+	}
+}
+
+func TestPacketCodecWriteRejectsZeroPacket(t *testing.T) {
+	if err := NewPacketReadWriter(&packetTestStream{}).WritePacket(&Packet{}); err == nil {
+		t.Fatal("accepted zero-size packet")
+	}
+}

package/srpc/packet-codec.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import vectors from '../testdata/packet-codec-vectors.json'
+import { Packet } from './rpcproto.pb.js'
+import {
+  decodePacketSource,
+  encodePacketSource,
+  lengthPrefixDecode,
+  prependLengthPrefixTransform,
+  uint32LEDecode,
+} from './packet.js'
+
+const bytes = (hex: string) =>
+  Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16))
+const hex = (
+  data: Uint8Array | { subarray: (start?: number, end?: number) => Uint8Array },
+) => Buffer.from(data.subarray()).toString('hex')
+const collect = async <T>(source: AsyncIterable<T> | Iterable<T>) => {
+  const out: T[] = []
+  for await (const value of source) out.push(value)
+  return out
+}
+
+type ValidVector = (typeof vectors.cases)[number] & {
+  packet_hex: string
+  frame_hex: string
+}
+const validCases: ValidVector[] = vectors.cases.filter(
+  (entry): entry is ValidVector => Boolean(entry.packet_hex && entry.frame_hex),
+)
+
+describe('packet codec golden vectors', () => {
+  it.each(validCases)(
+    '$name has exact protobuf and frame bytes',
+    async (entry) => {
+      const packet = Packet.fromBinary(bytes(entry.packet_hex))
+      const encoded = (
+        await collect(
+          encodePacketSource(
+            (async function* () {
+              yield packet
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(encoded)).toBe(entry.packet_hex)
+
+      const framed = (
+        await collect(
+          prependLengthPrefixTransform()(
+            (async function* () {
+              yield encoded
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(framed)).toBe(entry.frame_hex)
+    },
+  )
+
+  it('rejects zero and oversized encoded chunks', async () => {
+    const zero = (async function* () {
+      yield new Uint8Array()
+    })()
+    await expect(collect(prependLengthPrefixTransform()(zero))).rejects.toThrow(
+      'invalid packet length',
+    )
+    const oversized = (async function* () {
+      yield new Uint8Array(10_000_001)
+    })()
+    await expect(
+      collect(prependLengthPrefixTransform()(oversized)),
+    ).rejects.toThrow('invalid packet length')
+  })
+
+  it('rejects zero and oversized lengths, and truncated bodies', async () => {
+    const zero = (async function* () {
+      yield bytes('00000000')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(zero, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const oversized = (async function* () {
+      yield bytes('81969800')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(oversized, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const truncated = (async function* () {
+      yield bytes('040000000a01')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(truncated, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+
+  it('decodes fragmented and coalesced frames', async () => {
+    const frames = validCases.map((entry) => bytes(entry.frame_hex))
+    const combined = new Uint8Array(
+      frames.reduce((n, frame) => n + frame.length, 0),
+    )
+    let offset = 0
+    for (const frame of frames) {
+      combined.set(frame, offset)
+      offset += frame.length
+    }
+    const payloads = await collect(
+      lengthPrefixDecode(
+        (async function* () {
+          yield combined.subarray(0, 3)
+          yield combined.subarray(3, 11)
+          yield combined.subarray(11)
+        })(),
+        uint32LEDecode,
+      ),
+    )
+    expect(payloads.map(hex)).toEqual(
+      validCases.map((entry) => entry.packet_hex),
+    )
+    const decoded = await collect(
+      decodePacketSource(payloads.map((payload) => payload.slice())),
+    )
+    expect(decoded).toHaveLength(validCases.length)
+  })
+
+  it('rejects malformed protobuf and incomplete frame prefix', async () => {
+    const malformed = vectors.cases.find(
+      (entry) => entry.name === 'malformed_complete',
+    )!
+    expect(() =>
+      Packet.fromBinary(bytes(malformed.frame_hex!.slice(8))),
+    ).toThrow()
+    const incomplete = (async function* () {
+      yield bytes('010203')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(incomplete, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+})

package/srpc/packet-rw.go

@@ -65,7 +65,10 @@ func (r *PacketReadWriter) WritePacket(p *Packet) error {
 	defer r.writeMtx.Unlock()
 
 	msgSize := p.SizeVT()
-	if msgSize < 0 || msgSize > maxMessageSize {
+	if msgSize <= 0 {
+		return errors.New("unexpected zero message size")
+	}
+	if msgSize > maxMessageSize {
 		return errors.Errorf("message size %v greater than maximum %v", msgSize, maxMessageSize)
 	}
 
@@ -163,7 +166,11 @@ func (r *PacketReadWriter) ReadToHandler(cb PacketDataHandler) error {
 		}
 	}
 
-	// closed
+	// closed: a clean frame boundary has no buffered bytes; otherwise EOF
+	// ended a prefix or packet body before completion.
+	if currLen != 0 || r.buf.Len() != 0 {
+		return io.ErrUnexpectedEOF
+	}
 	return nil
 }
 

package/srpc/packet.cpp

@@ -6,78 +6,80 @@
 
 namespace starpc {
 
-PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
-  return [handler](const std::string &data) -> Error {
-    srpc::Packet pkt;
-    if (!pkt.ParseFromString(data)) {
-      return Error::InvalidMessage;
-    }
-    return handler(pkt);
-  };
+PacketDataHandler NewPacketDataHandler(PacketHandler handler)
+{
+	return [handler](const std::string &data) -> Error {
+		srpc::Packet pkt;
+		if (!pkt.ParseFromString(data))
+			return Error::InvalidMessage;
+		return handler(pkt);
+	};
 }
 
-Error ValidatePacket(const srpc::Packet &pkt) {
-  switch (pkt.body_case()) {
-  case srpc::Packet::kCallStart:
-    return ValidateCallStart(pkt.call_start());
-  case srpc::Packet::kCallData:
-    return ValidateCallData(pkt.call_data());
-  case srpc::Packet::kCallCancel:
-    return Error::OK;
-  default:
-    return Error::UnrecognizedPacket;
-  }
+Error ValidatePacket(const srpc::Packet &pkt)
+{
+	switch (pkt.body_case()) {
+	case srpc::Packet::kCallStart:
+		return ValidateCallStart(pkt.call_start());
+	case srpc::Packet::kCallData:
+		return ValidateCallData(pkt.call_data());
+	case srpc::Packet::kCallCancel:
+		return Error::OK;
+	default:
+		return Error::UnrecognizedPacket;
+	}
 }
 
-Error ValidateCallStart(const srpc::CallStart &pkt) {
-  if (pkt.rpc_method().empty()) {
-    return Error::EmptyMethodID;
-  }
-  if (pkt.rpc_service().empty()) {
-    return Error::EmptyServiceID;
-  }
-  return Error::OK;
+Error ValidateCallStart(const srpc::CallStart &pkt)
+{
+	if (pkt.rpc_method().empty())
+		return Error::EmptyMethodID;
+	if (pkt.rpc_service().empty())
+		return Error::EmptyServiceID;
+	return Error::OK;
 }
 
-Error ValidateCallData(const srpc::CallData &pkt) {
-  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
-      !pkt.data_is_zero()) {
-    return Error::EmptyPacket;
-  }
-  return Error::OK;
+Error ValidateCallData(const srpc::CallData &pkt)
+{
+	if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
+	    !pkt.data_is_zero())
+		return Error::EmptyPacket;
+	return Error::OK;
 }
 
 std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
-                                                 const std::string &method,
-                                                 const std::string &data,
-                                                 bool data_is_zero) {
-  auto pkt = std::make_unique<srpc::Packet>();
-  auto *call_start = pkt->mutable_call_start();
-  call_start->set_rpc_service(service);
-  call_start->set_rpc_method(method);
-  call_start->set_data(data);
-  call_start->set_data_is_zero(data_is_zero);
-  return pkt;
+						 const std::string &method,
+						 const std::string &data,
+						 bool data_is_zero)
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	auto *call_start = pkt->mutable_call_start();
+	call_start->set_rpc_service(service);
+	call_start->set_rpc_method(method);
+	call_start->set_data(data);
+	call_start->set_data_is_zero(data_is_zero);
+	return pkt;
 }
 
 std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
-                                                bool data_is_zero,
-                                                bool complete, Error err) {
-  auto pkt = std::make_unique<srpc::Packet>();
-  auto *call_data = pkt->mutable_call_data();
-  call_data->set_data(data);
-  call_data->set_data_is_zero(data_is_zero);
-  call_data->set_complete(err != Error::OK || complete);
-  if (err != Error::OK) {
-    call_data->set_error(ErrorString(err));
-  }
-  return pkt;
+						bool data_is_zero,
+						bool complete, Error err)
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	auto *call_data = pkt->mutable_call_data();
+	call_data->set_data(data);
+	call_data->set_data_is_zero(data_is_zero);
+	call_data->set_complete(err != Error::OK || complete);
+	if (err != Error::OK)
+		call_data->set_error(ErrorString(err));
+	return pkt;
 }
 
-std::unique_ptr<srpc::Packet> NewCallCancelPacket() {
-  auto pkt = std::make_unique<srpc::Packet>();
-  pkt->set_call_cancel(true);
-  return pkt;
+std::unique_ptr<srpc::Packet> NewCallCancelPacket()
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	pkt->set_call_cancel(true);
+	return pkt;
 }
 
 } // namespace starpc

package/srpc/packet.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
+#include "errors.hpp"
+
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 
-#include "errors.hpp"
-
 namespace srpc {
 class Packet;
 class CallStart;
@@ -15,42 +15,57 @@ class CallData;
 
 namespace starpc {
 
-// CloseHandler handles the stream closing with an optional error.
-// Matches Go CloseHandler in packet.go
+/*
+ * CloseHandler receives the transport close outcome for a stream.
+ * Matches Go CloseHandler in packet.go.
+ */
 using CloseHandler = std::function<void(Error close_err)>;
 
-// PacketHandler handles a packet.
-// Matches Go PacketHandler in packet.go
+/* PacketHandler receives one parsed packet. Matches Go PacketHandler. */
 using PacketHandler = std::function<Error(const srpc::Packet &pkt)>;
 
-// PacketDataHandler handles a packet before it is parsed.
-// Matches Go PacketDataHandler in packet.go
+/*
+ * PacketDataHandler receives one packet before parsing, as its serialized
+ * bytes. Matches Go PacketDataHandler in packet.go.
+ */
 using PacketDataHandler = std::function<Error(const std::string &data)>;
 
-// NewPacketDataHandler wraps a PacketHandler with a decoding step.
+/* NewPacketDataHandler parses each payload and forwards it to handler. */
 PacketDataHandler NewPacketDataHandler(PacketHandler handler);
 
-// Validate performs cursory validation of a Packet.
+/*
+ * ValidatePacket checks a packet's shape: its body is one of the known types
+ * and the body's required fields are present.
+ */
 Error ValidatePacket(const srpc::Packet &pkt);
 
-// Validate performs cursory validation of a CallStart.
+/* ValidateCallStart requires the service and method IDs to be present. */
 Error ValidateCallStart(const srpc::CallStart &pkt);
 
-// Validate performs cursory validation of a CallData.
+/*
+ * ValidateCallData rejects a packet that carries no data, no completion, no
+ * error, and no zero-length marker.
+ */
 Error ValidateCallData(const srpc::CallData &pkt);
 
-// NewCallStartPacket constructs a new CallStart packet.
+/*
+ * NewCallStartPacket builds the CallStart packet that opens a call.
+ * data_is_zero marks an intentionally empty first message.
+ */
 std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
-                                                 const std::string &method,
-                                                 const std::string &data,
-                                                 bool data_is_zero);
+						 const std::string &method,
+						 const std::string &data,
+						 bool data_is_zero);
 
-// NewCallDataPacket constructs a new CallData packet.
+/*
+ * NewCallDataPacket builds one CallData packet. err carries the call's
+ * terminal verdict; complete ends the sending side.
+ */
 std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
-                                                bool data_is_zero,
-                                                bool complete, Error err);
+						bool data_is_zero,
+						bool complete, Error err);
 
-// NewCallCancelPacket constructs a new CallCancel packet with cancel.
+/* NewCallCancelPacket builds the packet that cancels the call. */
 std::unique_ptr<srpc::Packet> NewCallCancelPacket();
 
 } // namespace starpc