@@ -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