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
|
package self_test
import (
"context"
"io"
"net"
"testing"
"time"
"github.com/quic-go/quic-go"
quicproxy "github.com/quic-go/quic-go/integrationtests/tools/proxy"
"github.com/stretchr/testify/require"
)
func TestEarlyData(t *testing.T) {
const rtt = 80 * time.Millisecond
ln, err := quic.ListenEarly(newUDPConnLocalhost(t), getTLSConfig(), getQuicConfig(nil))
require.NoError(t, err)
defer ln.Close()
proxy := &quicproxy.Proxy{
Conn: newUDPConnLocalhost(t),
ServerAddr: ln.Addr().(*net.UDPAddr),
DelayPacket: func(quicproxy.Direction, net.Addr, net.Addr, []byte) time.Duration { return rtt / 2 },
}
require.NoError(t, proxy.Start())
defer proxy.Close()
connChan := make(chan *quic.Conn)
errChan := make(chan error)
go func() {
conn, err := ln.Accept(context.Background())
if err != nil {
errChan <- err
return
}
connChan <- conn
}()
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
clientConn, err := quic.Dial(ctx, newUDPConnLocalhost(t), proxy.LocalAddr(), getTLSClientConfig(), getQuicConfig(nil))
require.NoError(t, err)
var serverConn *quic.Conn
select {
case serverConn = <-connChan:
case err := <-errChan:
t.Fatalf("error accepting connection: %s", err)
}
str, err := serverConn.OpenUniStream()
require.NoError(t, err)
_, err = str.Write([]byte("early data"))
require.NoError(t, err)
require.NoError(t, str.Close())
// the write should have completed before the handshake
select {
case <-serverConn.HandshakeComplete():
t.Fatal("handshake shouldn't be completed yet")
default:
}
clientStr, err := clientConn.AcceptUniStream(context.Background())
require.NoError(t, err)
data, err := io.ReadAll(clientStr)
require.NoError(t, err)
require.Equal(t, []byte("early data"), data)
clientConn.CloseWithError(0, "")
<-serverConn.Context().Done()
}
|
