ReplaceWithClosed func([]protocol.ConnectionID, []byte)
}
-type connRunners map[transportID]connRunnerCallbacks
+// The memory address of the Transport is used as the key.
+type connRunners map[*Transport]connRunnerCallbacks
func (cr connRunners) AddConnectionID(id protocol.ConnectionID) {
for _, c := range cr {
}
func newConnIDGenerator(
- tID transportID,
+ tr *Transport,
initialConnectionID protocol.ConnectionID,
initialClientDestConnID *protocol.ConnectionID, // nil for the client
statelessResetter *statelessResetter,
generator: generator,
activeSrcConnIDs: make(map[uint64]protocol.ConnectionID),
statelessResetter: statelessResetter,
- connRunners: map[transportID]connRunnerCallbacks{tID: connRunner},
+ connRunners: map[*Transport]connRunnerCallbacks{tr: connRunner},
queueControlFrame: queueControlFrame,
}
m.activeSrcConnIDs[0] = initialConnectionID
m.connRunners.ReplaceWithClosed(connIDs, connClose)
}
-func (m *connIDGenerator) AddConnRunner(id transportID, r connRunnerCallbacks) {
+func (m *connIDGenerator) AddConnRunner(id *Transport, r connRunnerCallbacks) {
// The transport might have already been added earlier.
// This happens if the application migrates back to and old path.
if _, ok := m.connRunners[id]; ok {
initialClientDestConnID = &connID
}
g := newConnIDGenerator(
- 1,
+ &Transport{},
protocol.ParseConnectionID([]byte{1, 1, 1, 1}),
initialClientDestConnID,
sr,
initialConnID := protocol.ParseConnectionID([]byte{2, 2, 2, 2})
var added, removed []protocol.ConnectionID
g := newConnIDGenerator(
- 1,
+ &Transport{},
protocol.ParseConnectionID([]byte{1, 1, 1, 1}),
&initialConnID,
newStatelessResetter(&StatelessResetKey{1, 2, 3, 4}),
removed []protocol.ConnectionID
)
g := newConnIDGenerator(
- 0,
+ &Transport{},
protocol.ParseConnectionID([]byte{1, 1, 1, 1}),
initialClientDestConnID,
newStatelessResetter(&StatelessResetKey{1, 2, 3, 4}),
replacedWith []byte
)
g := newConnIDGenerator(
- 1,
+ &Transport{},
protocol.ParseConnectionID([]byte{1, 1, 1, 1}),
initialClientDestConnID,
newStatelessResetter(&StatelessResetKey{1, 2, 3, 4}),
added, removed, replaced []protocol.ConnectionID
}
- var tracker1, tracker2 connIDTracker
+ var tracker1, tracker2, tracker3 connIDTracker
runner1 := connRunnerCallbacks{
AddConnectionID: func(c protocol.ConnectionID) { tracker1.added = append(tracker1.added, c) },
RemoveConnectionID: func(c protocol.ConnectionID) { tracker1.removed = append(tracker1.removed, c) },
tracker2.replaced = append(tracker2.replaced, connIDs...)
},
}
+ runner3 := connRunnerCallbacks{
+ AddConnectionID: func(c protocol.ConnectionID) { tracker3.added = append(tracker3.added, c) },
+ RemoveConnectionID: func(c protocol.ConnectionID) { tracker3.removed = append(tracker3.removed, c) },
+ ReplaceWithClosed: func(connIDs []protocol.ConnectionID, _ []byte) {
+ tracker3.replaced = append(tracker3.replaced, connIDs...)
+ },
+ }
sr := newStatelessResetter(&StatelessResetKey{1, 2, 3, 4})
var queuedFrames []wire.Frame
+ tr := &Transport{}
g := newConnIDGenerator(
- 1,
+ tr,
initialConnID,
&clientDestConnID,
sr,
require.Len(t, tracker1.added, 2)
// add the second runner - it should get all existing connection IDs
- g.AddConnRunner(2, runner2)
+ g.AddConnRunner(&Transport{}, runner2)
require.Len(t, tracker1.added, 2) // unchanged
require.Len(t, tracker2.added, 4)
require.Contains(t, tracker2.added, initialConnID)
require.Contains(t, tracker2.added, tracker1.added[0])
require.Contains(t, tracker2.added, tracker1.added[1])
+ // adding the same transport again doesn't do anything
+ trCopy := tr
+ g.AddConnRunner(trCopy, runner3)
+ require.Empty(t, tracker3.added)
+
var connIDToRetire protocol.ConnectionID
var seqToRetire uint64
ncid := queuedFrames[0].(*wire.NewConnectionIDFrame)
return ok
}
-type transportID uint64
-
-var transportIDCounter atomic.Uint64
-
var errListenerAlreadySet = errors.New("listener already set")
// The Transport is the central point to manage incoming and outgoing QUIC connections.
initOnce sync.Once
initErr error
- // Set in init.
- transportID transportID
// If no ConnectionIDGenerator is set, this is the ConnectionIDLength.
connIDLen int
// Set in init.
func (t *Transport) init(allowZeroLengthConnIDs bool) error {
t.initOnce.Do(func() {
- t.transportID = transportID(transportIDCounter.Add(1))
var conn rawConn
if c, ok := t.Conn.(rawConn); ok {
conn = c
return t.handlerMap
}
-func (t *Transport) id() transportID { return t.transportID }
-
// WriteTo sends a packet on the underlying connection.
func (t *Transport) WriteTo(b []byte, addr net.Addr) (int, error) {
if err := t.init(false); err != nil {