1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
package self_test
import (
"context"
"crypto/rand"
"fmt"
"io"
mrand "math/rand/v2"
"testing"
"time"
"github.com/quic-go/quic-go"
"github.com/quic-go/quic-go/internal/protocol"
"github.com/quic-go/quic-go/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type connIDGenerator struct {
Length int
}
var _ quic.ConnectionIDGenerator = &connIDGenerator{}
func (c *connIDGenerator) GenerateConnectionID() (quic.ConnectionID, error) {
b := make([]byte, c.Length)
if _, err := rand.Read(b); err != nil {
return quic.ConnectionID{}, fmt.Errorf("generating conn ID failed: %w", err)
}
return protocol.ParseConnectionID(b), nil
}
func (c *connIDGenerator) ConnectionIDLen() int { return c.Length }
func randomConnIDLen() int { return 2 + mrand.IntN(19) }
func TestConnectionIDsZeroLength(t *testing.T) {
testTransferWithConnectionIDs(t, randomConnIDLen(), 0, nil, nil)
}
func TestConnectionIDsRandomLengths(t *testing.T) {
testTransferWithConnectionIDs(t, randomConnIDLen(), randomConnIDLen(), nil, nil)
}
func TestConnectionIDsCustomGenerator(t *testing.T) {
testTransferWithConnectionIDs(t, 0, 0,
&connIDGenerator{Length: randomConnIDLen()},
&connIDGenerator{Length: randomConnIDLen()},
)
}
// connIDLen is ignored when connIDGenerator is set
func testTransferWithConnectionIDs(
t *testing.T,
serverConnIDLen, clientConnIDLen int,
serverConnIDGenerator, clientConnIDGenerator quic.ConnectionIDGenerator,
) {
t.Helper()
if serverConnIDGenerator != nil {
t.Logf("using %d byte connection ID generator for the server", serverConnIDGenerator.ConnectionIDLen())
} else {
t.Logf("issuing %d byte connection ID from the server", serverConnIDLen)
}
if clientConnIDGenerator != nil {
t.Logf("using %d byte connection ID generator for the client", clientConnIDGenerator.ConnectionIDLen())
} else {
t.Logf("issuing %d byte connection ID from the client", clientConnIDLen)
}
// setup server
serverTr := &quic.Transport{
Conn: newUDPConnLocalhost(t),
ConnectionIDLength: serverConnIDLen,
ConnectionIDGenerator: serverConnIDGenerator,
}
defer serverTr.Close()
addTracer(serverTr)
serverCounter, serverTracer := newPacketTracer()
ln, err := serverTr.Listen(
getTLSConfig(),
getQuicConfig(&quic.Config{
Tracer: func(context.Context, logging.Perspective, quic.ConnectionID) *logging.ConnectionTracer {
return serverTracer
},
}),
)
require.NoError(t, err)
// setup client
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
var conn *quic.Conn
clientCounter, clientTracer := newPacketTracer()
clientQUICConf := getQuicConfig(&quic.Config{
Tracer: func(context.Context, logging.Perspective, quic.ConnectionID) *logging.ConnectionTracer {
return clientTracer
},
})
if clientConnIDGenerator == nil && clientConnIDLen == 0 {
conn, err = quic.Dial(ctx, newUDPConnLocalhost(t), ln.Addr(), getTLSClientConfig(), clientQUICConf)
require.NoError(t, err)
} else {
clientTr := &quic.Transport{
Conn: newUDPConnLocalhost(t),
ConnectionIDLength: clientConnIDLen,
ConnectionIDGenerator: clientConnIDGenerator,
}
defer clientTr.Close()
addTracer(clientTr)
conn, err = clientTr.Dial(ctx, ln.Addr(), getTLSClientConfig(), clientQUICConf)
require.NoError(t, err)
}
serverConn, err := ln.Accept(context.Background())
require.NoError(t, err)
serverStr, err := serverConn.OpenStream()
require.NoError(t, err)
go func() {
serverStr.Write(PRData)
serverStr.Close()
}()
str, err := conn.AcceptStream(context.Background())
require.NoError(t, err)
data, err := io.ReadAll(str)
require.NoError(t, err)
require.Equal(t, PRData, data)
conn.CloseWithError(0, "")
serverConn.CloseWithError(0, "")
for _, p := range serverCounter.getRcvdShortHeaderPackets() {
expectedLen := serverConnIDLen
if serverConnIDGenerator != nil {
expectedLen = serverConnIDGenerator.ConnectionIDLen()
}
if !assert.Equal(t, expectedLen, p.hdr.DestConnectionID.Len(), "server conn length mismatch") {
break
}
}
for _, p := range clientCounter.getRcvdShortHeaderPackets() {
expectedLen := clientConnIDLen
if clientConnIDGenerator != nil {
expectedLen = clientConnIDGenerator.ConnectionIDLen()
}
if !assert.Equal(t, expectedLen, p.hdr.DestConnectionID.Len(), "client conn length mismatch") {
break
}
}
}
|
