fix application bug

vendor/github.com/lucas-clemente/quic-go/streams_map_outgoing_generic.go

@@ -5,24 +5,25 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/qerr"
 	"github.com/lucas-clemente/quic-go/internal/wire"
-	"github.com/lucas-clemente/quic-go/qerr"
 )
 
-//go:generate genny -in $GOFILE -out streams_map_outgoing_bidi.go gen "item=streamI Item=BidiStream"
-//go:generate genny -in $GOFILE -out streams_map_outgoing_uni.go gen "item=sendStreamI Item=UniStream"
+//go:generate genny -in $GOFILE -out streams_map_outgoing_bidi.go gen "item=streamI Item=BidiStream streamTypeGeneric=protocol.StreamTypeBidi"
+//go:generate genny -in $GOFILE -out streams_map_outgoing_uni.go gen "item=sendStreamI Item=UniStream streamTypeGeneric=protocol.StreamTypeUni"
 type outgoingItemsMap struct {
 	mutex sync.RWMutex
 	cond  sync.Cond
 
 	streams map[protocol.StreamID]item
 
-	nextStream     protocol.StreamID // stream ID of the stream returned by OpenStream(Sync)
-	maxStream      protocol.StreamID // the maximum stream ID we're allowed to open
-	highestBlocked protocol.StreamID // the highest stream ID that we queued a STREAM_ID_BLOCKED frame for
+	nextStream   protocol.StreamID // stream ID of the stream returned by OpenStream(Sync)
+	maxStream    protocol.StreamID // the maximum stream ID we're allowed to open
+	maxStreamSet bool              // was maxStream set. If not, it's not possible to any stream (also works for stream 0)
+	blockedSent  bool              // was a STREAMS_BLOCKED sent for the current maxStream
 
 	newStream            func(protocol.StreamID) item
-	queueStreamIDBlocked func(*wire.StreamIDBlockedFrame)
+	queueStreamIDBlocked func(*wire.StreamsBlockedFrame)
 
 	closeErr error
 }
@@ -36,7 +37,7 @@ func newOutgoingItemsMap(
 		streams:              make(map[protocol.StreamID]item),
 		nextStream:           nextStream,
 		newStream:            newStream,
-		queueStreamIDBlocked: func(f *wire.StreamIDBlockedFrame) { queueControlFrame(f) },
+		queueStreamIDBlocked: func(f *wire.StreamsBlockedFrame) { queueControlFrame(f) },
 	}
 	m.cond.L = &m.mutex
 	return m
@@ -46,7 +47,15 @@ func (m *outgoingItemsMap) OpenStream() (item, error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
-	return m.openStreamImpl()
+	if m.closeErr != nil {
+		return nil, m.closeErr
+	}
+
+	str, err := m.openStreamImpl()
+	if err != nil {
+		return nil, streamOpenErr{err}
+	}
+	return str, nil
 }
 
 func (m *outgoingItemsMap) OpenStreamSync() (item, error) {
@@ -54,27 +63,37 @@ func (m *outgoingItemsMap) OpenStreamSync() (item, error) {
 	defer m.mutex.Unlock()
 
 	for {
+		if m.closeErr != nil {
+			return nil, m.closeErr
+		}
 		str, err := m.openStreamImpl()
 		if err == nil {
-			return str, err
+			return str, nil
 		}
-		if err != nil && err != qerr.TooManyOpenStreams {
-			return nil, err
+		if err != nil && err != errTooManyOpenStreams {
+			return nil, streamOpenErr{err}
 		}
 		m.cond.Wait()
 	}
 }
 
 func (m *outgoingItemsMap) openStreamImpl() (item, error) {
-	if m.closeErr != nil {
-		return nil, m.closeErr
-	}
-	if m.nextStream > m.maxStream {
-		if m.maxStream == 0 || m.highestBlocked < m.maxStream {
-			m.queueStreamIDBlocked(&wire.StreamIDBlockedFrame{StreamID: m.maxStream})
-			m.highestBlocked = m.maxStream
+	if !m.maxStreamSet || m.nextStream > m.maxStream {
+		if !m.blockedSent {
+			if m.maxStreamSet {
+				m.queueStreamIDBlocked(&wire.StreamsBlockedFrame{
+					Type:        streamTypeGeneric,
+					StreamLimit: m.maxStream.StreamNum(),
+				})
+			} else {
+				m.queueStreamIDBlocked(&wire.StreamsBlockedFrame{
+					Type:        streamTypeGeneric,
+					StreamLimit: 0,
+				})
+			}
+			m.blockedSent = true
 		}
-		return nil, qerr.TooManyOpenStreams
+		return nil, errTooManyOpenStreams
 	}
 	s := m.newStream(m.nextStream)
 	m.streams[m.nextStream] = s
@@ -86,7 +105,7 @@ func (m *outgoingItemsMap) GetStream(id protocol.StreamID) (item, error) {
 	m.mutex.RLock()
 	if id >= m.nextStream {
 		m.mutex.RUnlock()
-		return nil, qerr.Error(qerr.InvalidStreamID, fmt.Sprintf("peer attempted to open stream %d", id))
+		return nil, qerr.Error(qerr.StreamStateError, fmt.Sprintf("peer attempted to open stream %d", id))
 	}
 	s := m.streams[id]
 	m.mutex.RUnlock()
@@ -106,8 +125,10 @@ func (m *outgoingItemsMap) DeleteStream(id protocol.StreamID) error {
 
 func (m *outgoingItemsMap) SetMaxStream(id protocol.StreamID) {
 	m.mutex.Lock()
-	if id > m.maxStream {
+	if !m.maxStreamSet || id > m.maxStream {
 		m.maxStream = id
+		m.maxStreamSet = true
+		m.blockedSent = false
 		m.cond.Broadcast()
 	}
 	m.mutex.Unlock()