From 39969134bb86d997557b41fd54e09d2909b816bb Mon Sep 17 00:00:00 2001 From: Anish Pentyala Date: Tue, 17 Nov 2026 12:49:55 -0800 Subject: [PATCH 1/3] fix(netconn): return from zero-length reads without waiting A zero-length buffer cannot receive message data. Return without reading while preserving known EOF and expired-deadline errors, and keep skipping empty messages for nonempty buffers. --- netconn.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/netconn.go b/netconn.go index a854faa4..7b1bbdc8 100644 --- a/netconn.go +++ b/netconn.go @@ -146,7 +146,7 @@ func (nc *netConn) Read(p []byte) (int, error) { if err != nil { return n, err } - if n == 0 { + if n == 0 && len(p) != 0 { continue } return n, nil @@ -162,6 +162,10 @@ func (nc *netConn) read(p []byte) (int, error) { return 0, io.EOF } + if len(p) == 0 { + return 0, nil + } + if nc.reader == nil { typ, r, err := nc.c.Reader(nc.readCtx) if err != nil { From 0ffc0162e3dff3146d19e5994d4d2c336ed64168 Mon Sep 17 00:00:00 2001 From: Anish Pentyala Date: Tue, 17 Nov 2026 12:50:21 -0800 Subject: [PATCH 2/3] test(netconn): cover empty buffers and preserve message behavior Cover nil and empty buffers on idle and buffered connections, plus deadline reset and empty-message skipping controls. --- conn_test.go | 87 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/conn_test.go b/conn_test.go index c03c02b3..fcd0e9e0 100644 --- a/conn_test.go +++ b/conn_test.go @@ -356,6 +356,93 @@ func TestConn(t *testing.T) { assert.Equal(t, "read msg", []byte("hello"), b) }) + t.Run("netConn/zeroLengthRead", func(t *testing.T) { + for _, buffered := range []bool{false, true} { + for _, empty := range [][]byte{nil, {}} { + t.Run(fmt.Sprintf("buffered=%v/nil=%v", buffered, empty == nil), func(t *testing.T) { + tt, c1, c2 := newConnTest(t, nil, nil) + n1 := websocket.NetConn(tt.ctx, c1, websocket.MessageBinary) + n2 := websocket.NetConn(tt.ctx, c2, websocket.MessageBinary) + + if buffered { + written := xsync.Go(func() error { + _, err := n2.Write([]byte("hello")) + return err + }) + first := make([]byte, 1) + _, err := io.ReadFull(n1, first) + assert.Success(t, err) + assert.Equal(t, "first byte", "h", string(first)) + assert.Success(t, <-written) + } + + done := make(chan error, 1) + go func() { + n, err := n1.Read(empty) + if n != 0 || err != nil { + err = fmt.Errorf("zero-length Read = (%d, %v), want (0, nil)", n, err) + } + done <- err + }() + select { + case err := <-done: + assert.Success(t, err) + case <-time.After(time.Second): + c1.CloseNow() + <-done + t.Fatal("zero-length Read blocked on an open connection") + } + + if buffered { + rest := make([]byte, 4) + _, err := io.ReadFull(n1, rest) + assert.Success(t, err) + assert.Equal(t, "remaining message", "ello", string(rest)) + } + }) + } + } + }) + + t.Run("netConn/emptyMessages", func(t *testing.T) { + tt, c1, c2 := newConnTest(t, nil, nil) + n1 := websocket.NetConn(tt.ctx, c1, websocket.MessageBinary) + written := xsync.Go(func() error { + for _, msg := range []string{"", "", "hello"} { + if err := c2.Write(tt.ctx, websocket.MessageBinary, []byte(msg)); err != nil { + return err + } + } + return nil + }) + buf := make([]byte, 5) + n, err := n1.Read(buf) + assert.Success(t, err) + assert.Equal(t, "read count", len(buf), n) + assert.Equal(t, "message", "hello", string(buf)) + assert.Success(t, <-written) + }) + + t.Run("netConn/zeroLengthReadDeadline", func(t *testing.T) { + tt, c1, _ := newConnTest(t, nil, nil) + n1 := websocket.NetConn(tt.ctx, c1, websocket.MessageBinary) + assert.Success(t, n1.SetReadDeadline(time.Now().Add(-time.Second))) + // Wait for the idle deadline callback to mark the read as expired. + var err error + for until := time.Now().Add(time.Second); time.Now().Before(until); { + _, err = n1.Read(nil) + if err != nil { + break + } + time.Sleep(time.Millisecond) + } + assert.ErrorIs(t, context.DeadlineExceeded, err) + assert.Success(t, n1.SetReadDeadline(time.Time{})) + n, err := n1.Read(nil) + assert.Success(t, err) + assert.Equal(t, "read count", 0, n) + }) + t.Run("netConn/BadMsg", func(t *testing.T) { tt, c1, c2 := newConnTest(t, nil, nil) From ec56dc01061b32cf63ab4e88e52b67699ec3295f Mon Sep 17 00:00:00 2001 From: Anish Pentyala Date: Tue, 17 Nov 2026 12:50:47 -0800 Subject: [PATCH 3/3] test(netconn): cover zero-length reads in browser Wasm Check idle and buffered connections with nil and empty buffers while preserving the buffered message remainder. --- ws_js_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/ws_js_test.go b/ws_js_test.go index a1d846fa..74da492d 100644 --- a/ws_js_test.go +++ b/ws_js_test.go @@ -87,3 +87,53 @@ func TestWasmDialTimeout(t *testing.T) { t.Fatal("wasm context dial timeout is not working", time.Since(beforeDial)) } } + +func TestWasmNetConnZeroLengthRead(t *testing.T) { + for _, buffered := range []bool{false, true} { + name := "idle" + if buffered { + name = "buffered" + } + t.Run(name, func(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + c, _, err := websocket.Dial(ctx, os.Getenv("WS_ECHO_SERVER_URL"), &websocket.DialOptions{ + Subprotocols: []string{"echo"}, + }) + assert.Success(t, err) + defer c.Close(websocket.StatusNormalClosure, "") + nc := websocket.NetConn(ctx, c, websocket.MessageBinary) + if buffered { + _, err = nc.Write([]byte("hello")) + assert.Success(t, err) + first := make([]byte, 1) + _, err = nc.Read(first) + assert.Success(t, err) + assert.Equal(t, "first byte", "h", string(first)) + } + for _, empty := range [][]byte{nil, {}} { + done := make(chan struct{}) + go func() { + defer close(done) + n, err := nc.Read(empty) + assert.Success(t, err) + assert.Equal(t, "read count", 0, n) + }() + select { + case <-done: + case <-time.After(time.Second): + c.Close(websocket.StatusNormalClosure, "") + <-done + t.Fatal("zero-length Read blocked on an open connection") + } + } + if buffered { + rest := make([]byte, 4) + _, err = nc.Read(rest) + assert.Success(t, err) + assert.Equal(t, "remaining message", "ello", string(rest)) + } + assert.Success(t, c.Close(websocket.StatusNormalClosure, "")) + }) + } +}