diff --git a/net/memnet/pipe.go b/net/memnet/pipe.go index 8caca57df..6f0fa4e45 100644 --- a/net/memnet/pipe.go +++ b/net/memnet/pipe.go @@ -160,8 +160,13 @@ func (p *Pipe) Close() error { return nil } +// deadlineTimer arranges to wake blocked readers and writers at t, returning +// a func that cancels that, or nil if there's nothing to cancel. It must be +// called with p.mu held. func (p *Pipe) deadlineTimer(t time.Time) func() { - if t.IsZero() { + // A closed pipe has no one left to wake, and nothing would ever cancel + // a timer armed now: Close cancels only the ones it finds. + if t.IsZero() || p.closed { return nil } if t.Before(time.Now()) { diff --git a/net/memnet/pipe_test.go b/net/memnet/pipe_test.go index ebd9dd8c2..96c062841 100644 --- a/net/memnet/pipe_test.go +++ b/net/memnet/pipe_test.go @@ -8,6 +8,7 @@ import ( "fmt" "os" "testing" + "testing/synctest" "time" ) @@ -115,3 +116,22 @@ func TestLimit(t *testing.T) { t.Error(err) } } + +// TestDeadlineAfterClose checks that setting a deadline on a closed pipe +// doesn't leave a timer goroutine behind. An http.Server can do that if it's +// closed between accepting a conn and starting its TLS handshake, which sets +// the handshake deadlines. synctest.Test fails if a goroutine started in its +// bubble is still blocked when it returns. +func TestDeadlineAfterClose(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + p := NewPipe("p1", 1<<16) + p.Close() + dl := time.Now().Add(time.Hour) + if err := p.SetReadDeadline(dl); err != nil { + t.Fatal(err) + } + if err := p.SetWriteDeadline(dl); err != nil { + t.Fatal(err) + } + }) +}