Skip to content

Commit 076bb1c

Browse files
Cherrypick #9533 to v1.85.x. (#9534)
1 parent baaf083 commit 076bb1c

2 files changed

Lines changed: 142 additions & 1 deletion

File tree

‎internal/transport/transport.go‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -121,7 +121,9 @@ func (b *recvBuffer) put(r recvMsg) {
121121
if b.err != nil {
122122
// drop the buffer on the floor. Since b.err is not nil, any subsequent reads
123123
// will always return an error, making this buffer inaccessible.
124-
r.buffer.Free()
124+
if r.buffer != nil {
125+
r.buffer.Free()
126+
}
125127
// An error had occurred earlier, don't accept more
126128
// data or errors.
127129
return

‎test/end2end_test.go‎

Lines changed: 139 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7513,3 +7513,142 @@ func (s) TestEnable8KBDefaultHeaderListSize_ServerSendsLargeHeaders(t *testing.T
75137513
})
75147514
}
75157515
}
7516+
7517+
// rpcEndStatsHandler signals done once the server-side RPC handler has called
7518+
// WriteStatus (which invokes finishStream and sets s.state = streamDone) and
7519+
// exited processRPC.
7520+
type rpcEndStatsHandler struct {
7521+
done *grpcsync.Event
7522+
}
7523+
7524+
func (h *rpcEndStatsHandler) TagRPC(ctx context.Context, _ *stats.RPCTagInfo) context.Context {
7525+
return ctx
7526+
}
7527+
7528+
func (h *rpcEndStatsHandler) HandleRPC(_ context.Context, rs stats.RPCStats) {
7529+
if _, ok := rs.(*stats.End); ok {
7530+
h.done.Fire()
7531+
}
7532+
}
7533+
7534+
func (h *rpcEndStatsHandler) TagConn(ctx context.Context, _ *stats.ConnTagInfo) context.Context {
7535+
return ctx
7536+
}
7537+
7538+
func (h *rpcEndStatsHandler) HandleConn(context.Context, stats.ConnStats) {}
7539+
7540+
// readNextNonControlFrame reads the next HTTP/2 frame from st, skipping flow
7541+
// control WINDOW_UPDATE frames and server-initiated (non-ACK) PING frames.
7542+
func readNextNonControlFrame(st *serverTester) (http2.Frame, error) {
7543+
for {
7544+
f, err := st.readFrame()
7545+
if err != nil {
7546+
return nil, err
7547+
}
7548+
switch f := f.(type) {
7549+
case *http2.WindowUpdateFrame:
7550+
continue
7551+
case *http2.PingFrame:
7552+
if !f.IsAck() {
7553+
continue
7554+
}
7555+
return f, nil
7556+
default:
7557+
return f, nil
7558+
}
7559+
}
7560+
}
7561+
7562+
// Test verifies that a second DATA+END_STREAM frame sent on a stream that
7563+
// has already transitioned to streamDone (while still in activeStreams due
7564+
// to zero peer flow-control window) does not panic the server's HandleStreams
7565+
// reader goroutine via a nil mem.Buffer Free() in recvBuffer.put().
7566+
func (s) TestDataFrameAfterStreamDone(t *testing.T) {
7567+
lis, err := testutils.LocalTCPListener()
7568+
if err != nil {
7569+
t.Fatalf("Failed to create listener: %v", err)
7570+
}
7571+
defer lis.Close()
7572+
7573+
sh := &rpcEndStatsHandler{done: grpcsync.NewEvent()}
7574+
srv := grpc.NewServer(grpc.StatsHandler(sh))
7575+
healthgrpc.RegisterHealthServer(srv, health.NewServer())
7576+
go srv.Serve(lis)
7577+
defer srv.Stop()
7578+
7579+
conn, err := net.DialTimeout("tcp", lis.Addr().String(), defaultTestTimeout)
7580+
if err != nil {
7581+
t.Fatalf("Failed to dial server: %v", err)
7582+
}
7583+
defer conn.Close()
7584+
7585+
st := newServerTesterFromConn(t, conn)
7586+
// Advertise SETTINGS_INITIAL_WINDOW_SIZE = 0 so the unary response DATA
7587+
// frame and trailing HEADERS (cleanupStream) remain buffered in
7588+
// loopyWriter, keeping Stream in t.activeStreams after finishStream sets
7589+
// s.state = streamDone.
7590+
st.greetWithSettings(http2.Setting{
7591+
ID: http2.SettingInitialWindowSize,
7592+
Val: 0,
7593+
})
7594+
7595+
// Open Stream 1 with initial HEADERS (EndStream=false) to invoke the
7596+
// unary Health/Check handler on the server.
7597+
st.writeHeaders(http2.HeadersFrameParam{
7598+
StreamID: 1,
7599+
BlockFragment: st.encodeHeader(
7600+
":method", "POST",
7601+
":path", "/grpc.health.v1.Health/Check",
7602+
":scheme", "http",
7603+
":authority", "localhost",
7604+
"content-type", "application/grpc",
7605+
"te", "trailers",
7606+
),
7607+
EndStream: false,
7608+
EndHeaders: true,
7609+
})
7610+
7611+
// Send an empty request message (a 5-byte gRPC Length-Prefixed-Message
7612+
// header: Compressed-Flag=0, Message-Length=0) with EndStream=true. The
7613+
// message lets the unary handler run and produce a response DATA frame;
7614+
// EndStream half-closes the client side, setting s.buf.err = io.EOF and
7615+
// moving the server stream from streamActive to streamReadDone.
7616+
st.writeData(1, true, []byte{0, 0, 0, 0, 0})
7617+
7618+
// Read the server's initial response HEADERS frame.
7619+
f, err := readNextNonControlFrame(st)
7620+
if err != nil {
7621+
t.Fatalf("Error reading response HEADERS frame from server: %v", err)
7622+
}
7623+
if f.Header().Type != http2.FrameHeaders {
7624+
t.Fatalf("Received frame %v; want response HEADERS frame", f)
7625+
}
7626+
7627+
// Wait for the server's unary handler to finish, call finishStream
7628+
// (transitioning s.state from streamReadDone to streamDone), and exit.
7629+
select {
7630+
case <-sh.done.Done():
7631+
case <-time.After(defaultTestTimeout):
7632+
t.Fatal("Timed out waiting for server unary handler to finish stream")
7633+
}
7634+
7635+
// Send a second DATA frame with EndStream=true on the same stream now that
7636+
// its state is streamDone (while still present in t.activeStreams).
7637+
// This triggers a second s.write(recvMsg{err: io.EOF}) with a nil buffer
7638+
// into recvBuffer.put() when b.err is already non-nil.
7639+
st.writeData(1, true, nil)
7640+
7641+
// Send a PING frame after the second DATA frame and verify the server's
7642+
// HandleStreams reader goroutine did not panic and replies with PING ACK.
7643+
pingData := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
7644+
if err := st.fr.WritePing(false, pingData); err != nil {
7645+
t.Fatalf("Error writing PING frame: %v", err)
7646+
}
7647+
f, err = readNextNonControlFrame(st)
7648+
if err != nil {
7649+
t.Fatalf("Error reading PING ACK frame from server: %v", err)
7650+
}
7651+
if pf, ok := f.(*http2.PingFrame); !ok || !pf.IsAck() || pf.Data != pingData {
7652+
t.Fatalf("Received frame %v; want PING ACK with data %v", f, pingData)
7653+
}
7654+
}

0 commit comments

Comments
 (0)