use stream numbers, not stream ids, in the stream maps

streams_map_incoming_generic.go

@@ -1,7 +1,6 @@
 package quic
 
 import (
-	"fmt"
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/internal/protocol"
@@ -14,38 +13,39 @@ type incomingItemsMap struct {
 	mutex sync.RWMutex
 	cond  sync.Cond
 
-	streams map[protocol.StreamID]item
+	streams map[protocol.StreamNum]item
 	// When a stream is deleted before it was accepted, we can't delete it immediately.
 	// We need to wait until the application accepts it, and delete it immediately then.
-	streamsToDelete map[protocol.StreamID]struct{} // used as a set
+	streamsToDelete map[protocol.StreamNum]struct{} // used as a set
 
-	nextStreamToAccept protocol.StreamID // the next stream that will be returned by AcceptStream()
-	nextStreamToOpen   protocol.StreamID // the highest stream that the peer openend
-	maxStream          protocol.StreamID // the highest stream that the peer is allowed to open
-	maxNumStreams      uint64            // maximum number of streams
+	nextStreamToAccept protocol.StreamNum // the next stream that will be returned by AcceptStream()
+	nextStreamToOpen   protocol.StreamNum // the highest stream that the peer openend
+	maxStream          protocol.StreamNum // the highest stream that the peer is allowed to open
+	maxNumStreams      uint64             // maximum number of streams
 
-	newStream        func(protocol.StreamID) item
+	newStream        func(protocol.StreamNum) item
 	queueMaxStreamID func(*wire.MaxStreamsFrame)
+	// streamNumToID    func(protocol.StreamNum) protocol.StreamID // only used for generating errors
 
 	closeErr error
 }
 
 func newIncomingItemsMap(
-	nextStreamToAccept protocol.StreamID,
-	initialMaxStreamID protocol.StreamID,
-	maxNumStreams uint64,
+	newStream func(protocol.StreamNum) item,
+	maxStreams uint64,
 	queueControlFrame func(wire.Frame),
-	newStream func(protocol.StreamID) item,
+	// streamNumToID func(protocol.StreamNum) protocol.StreamID,
 ) *incomingItemsMap {
 	m := &incomingItemsMap{
-		streams:            make(map[protocol.StreamID]item),
-		streamsToDelete:    make(map[protocol.StreamID]struct{}),
-		nextStreamToAccept: nextStreamToAccept,
-		nextStreamToOpen:   nextStreamToAccept,
-		maxStream:          initialMaxStreamID,
-		maxNumStreams:      maxNumStreams,
+		streams:            make(map[protocol.StreamNum]item),
+		streamsToDelete:    make(map[protocol.StreamNum]struct{}),
+		maxStream:          protocol.StreamNum(maxStreams),
+		maxNumStreams:      maxStreams,
 		newStream:          newStream,
+		nextStreamToOpen:   1,
+		nextStreamToAccept: 1,
 		queueMaxStreamID:   func(f *wire.MaxStreamsFrame) { queueControlFrame(f) },
+		// streamNumToID:      streamNumToID,
 	}
 	m.cond.L = &m.mutex
 	return m
@@ -55,45 +55,48 @@ func (m *incomingItemsMap) AcceptStream() (item, error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
-	var id protocol.StreamID
+	var num protocol.StreamNum
 	var str item
 	for {
-		id = m.nextStreamToAccept
+		num = m.nextStreamToAccept
 		var ok bool
 		if m.closeErr != nil {
 			return nil, m.closeErr
 		}
-		str, ok = m.streams[id]
+		str, ok = m.streams[num]
 		if ok {
 			break
 		}
 		m.cond.Wait()
 	}
-	m.nextStreamToAccept += 4
+	m.nextStreamToAccept++
 	// If this stream was completed before being accepted, we can delete it now.
-	if _, ok := m.streamsToDelete[id]; ok {
-		delete(m.streamsToDelete, id)
-		if err := m.deleteStream(id); err != nil {
+	if _, ok := m.streamsToDelete[num]; ok {
+		delete(m.streamsToDelete, num)
+		if err := m.deleteStream(num); err != nil {
 			return nil, err
 		}
 	}
 	return str, nil
 }
 
-func (m *incomingItemsMap) GetOrOpenStream(id protocol.StreamID) (item, error) {
+func (m *incomingItemsMap) GetOrOpenStream(num protocol.StreamNum) (item, error) {
 	m.mutex.RLock()
-	if id > m.maxStream {
+	if num > m.maxStream {
 		m.mutex.RUnlock()
-		return nil, fmt.Errorf("peer tried to open stream %d (current limit: %d)", id, m.maxStream)
+		return nil, streamError{
+			message: "peer tried to open stream %d (current limit: %d)",
+			nums:    []protocol.StreamNum{num, m.maxStream},
+		}
 	}
-	// if the id is smaller than the highest we accepted
+	// if the num is smaller than the highest we accepted
 	// * this stream exists in the map, and we can return it, or
 	// * this stream was already closed, then we can return the nil
-	if id < m.nextStreamToOpen {
+	if num < m.nextStreamToOpen {
 		var s item
 		// If the stream was already queued for deletion, and is just waiting to be accepted, don't return it.
-		if _, ok := m.streamsToDelete[id]; !ok {
-			s = m.streams[id]
+		if _, ok := m.streamsToDelete[num]; !ok {
+			s = m.streams[num]
 		}
 		m.mutex.RUnlock()
 		return s, nil
@@ -104,46 +107,52 @@ func (m *incomingItemsMap) GetOrOpenStream(id protocol.StreamID) (item, error) {
 	// no need to check the two error conditions from above again
 	// * maxStream can only increase, so if the id was valid before, it definitely is valid now
 	// * highestStream is only modified by this function
-	for newID := m.nextStreamToOpen; newID <= id; newID += 4 {
-		m.streams[newID] = m.newStream(newID)
+	for newNum := m.nextStreamToOpen; newNum <= num; newNum++ {
+		m.streams[newNum] = m.newStream(newNum)
 		m.cond.Signal()
 	}
-	m.nextStreamToOpen = id + 4
-	s := m.streams[id]
+	m.nextStreamToOpen = num + 1
+	s := m.streams[num]
 	m.mutex.Unlock()
 	return s, nil
 }
 
-func (m *incomingItemsMap) DeleteStream(id protocol.StreamID) error {
+func (m *incomingItemsMap) DeleteStream(num protocol.StreamNum) error {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
-	return m.deleteStream(id)
+	return m.deleteStream(num)
 }
 
-func (m *incomingItemsMap) deleteStream(id protocol.StreamID) error {
-	if _, ok := m.streams[id]; !ok {
-		return fmt.Errorf("Tried to delete unknown stream %d", id)
+func (m *incomingItemsMap) deleteStream(num protocol.StreamNum) error {
+	if _, ok := m.streams[num]; !ok {
+		return streamError{
+			message: "Tried to delete unknown stream %d",
+			nums:    []protocol.StreamNum{num},
+		}
 	}
 
 	// Don't delete this stream yet, if it was not yet accepted.
 	// Just save it to streamsToDelete map, to make sure it is deleted as soon as it gets accepted.
-	if id >= m.nextStreamToAccept {
-		if _, ok := m.streamsToDelete[id]; ok {
-			return fmt.Errorf("Tried to delete stream %d multiple times", id)
+	if num >= m.nextStreamToAccept {
+		if _, ok := m.streamsToDelete[num]; ok {
+			return streamError{
+				message: "Tried to delete stream %d multiple times",
+				nums:    []protocol.StreamNum{num},
+			}
 		}
-		m.streamsToDelete[id] = struct{}{}
+		m.streamsToDelete[num] = struct{}{}
 		return nil
 	}
 
-	delete(m.streams, id)
+	delete(m.streams, num)
 	// queue a MAX_STREAM_ID frame, giving the peer the option to open a new stream
 	if m.maxNumStreams > uint64(len(m.streams)) {
 		numNewStreams := m.maxNumStreams - uint64(len(m.streams))
-		m.maxStream = m.nextStreamToOpen + protocol.StreamID((numNewStreams-1)*4)
+		m.maxStream = m.nextStreamToOpen + protocol.StreamNum(numNewStreams) - 1
 		m.queueMaxStreamID(&wire.MaxStreamsFrame{
 			Type:         streamTypeGeneric,
-			MaxStreamNum: m.maxStream.StreamNum(),
+			MaxStreamNum: m.maxStream,
 		})
 	}
 	return nil