From 90a29b578a82e8289e7188586c58a1d8d18cbf2b Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 13:45:45 +0200 Subject: [PATCH 01/16] update to quic-go v0.35.1 --- go.mod | 2 +- go.sum | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 7376276f0d..9c2fd37a16 100644 --- a/go.mod +++ b/go.mod @@ -33,7 +33,7 @@ require ( github.com/pborman/getopt/v2 v2.1.0 github.com/pion/stun v0.6.0 github.com/pkg/errors v0.9.1 - github.com/quic-go/quic-go v0.33.0 + github.com/quic-go/quic-go v0.35.1 github.com/rogpeppe/go-internal v1.10.0 github.com/rubenv/sql-migrate v1.4.0 github.com/schollz/progressbar/v3 v3.13.1 diff --git a/go.sum b/go.sum index 30cb27527a..058d0752c7 100644 --- a/go.sum +++ b/go.sum @@ -83,6 +83,7 @@ github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMx github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= github.com/a8m/expect v1.0.0/go.mod h1:4IwSCMumY49ScypDnjNbYEjgVeqy1/U2cEs3Lat96eA= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= +github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412/go.mod h1:WPjqKcmVOxf0XSf3YxCJs6N6AOSrOx3obionmG7T0y0= github.com/alecthomas/kingpin/v2 v2.3.2 h1:H0aULhgmSzN8xQ3nX1uxtdlTHYoPLu5AhHxWrKI6ocU= github.com/alecthomas/kingpin/v2 v2.3.2/go.mod h1:0gyi0zQnjuFk8xrkNKamJoyUo382HRL7ATRpFZCw6tE= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= @@ -239,6 +240,7 @@ github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vb github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= +github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= @@ -460,6 +462,7 @@ github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0f github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= github.com/jackc/puddle v1.2.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= +github.com/jinzhu/copier v0.3.5/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= github.com/josharian/native v1.0.0 h1:Ts/E8zCSEsG17dUqv7joXJFybuMLjQfWE04tsBODTxk= @@ -470,6 +473,7 @@ github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= @@ -483,6 +487,8 @@ github.com/karrick/godirwalk v1.16.1 h1:DynhcF+bztK8gooS0+NDJFrdNZjJ3gzVzC545UNA github.com/karrick/godirwalk v1.16.1/go.mod h1:j4mkqPuvaLI8mp1DroR3P6ad7cyYd4c1qeJ3RV7ULlk= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= +github.com/keltia/proxy v0.9.3/go.mod h1:fLU4DmBPG0oh0md9fWggE2oG2m7Lchv3eim+GiO3pZY= +github.com/keltia/ripe-atlas v0.0.0-20211221125000-f6eb808d5dc6/go.mod h1:zYa+dM8811qRhclezc/AKX9imyQwPjjSk2cH0xTgTag= github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= @@ -599,6 +605,7 @@ github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE= github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= github.com/mroth/weightedrand v1.0.0 h1:V8JeHChvl2MP1sAoXq4brElOcza+jxLkRuwvtQu8L3E= @@ -787,6 +794,8 @@ github.com/quic-go/qtls-go1-20 v0.2.2 h1:WLOPx6OY/hxtTxKV1Zrq20FtXtDEkeY00CGQm8G github.com/quic-go/qtls-go1-20 v0.2.2/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM= github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y0= github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA= +github.com/quic-go/quic-go v0.35.1 h1:b0kzj6b/cQAf05cT0CkQubHM31wiA+xH3IBkxP62poo= +github.com/quic-go/quic-go v0.35.1/go.mod h1:+4CVgVppm0FNjpG3UcX8Joi/frKOH7/ciD5yGcwOO1g= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/refraction-networking/conjure v0.4.0 h1:YObJ+6L/MnupE82N2+3m93GMzlHjHSHe1ysIYDOpqug= github.com/refraction-networking/conjure v0.4.0/go.mod h1:7na+SFWdaTOToNoNrsJRIj4CIMwdGFZ4kwb/CO5Z0rQ= From baa25c5b6e00995e463d4b179956d83267245cc4 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 13:47:33 +0200 Subject: [PATCH 02/16] (change from v0.34.0): chan instead of context in Connection.HandshakeComplete --- internal/measurex/quic.go | 2 +- internal/mocks/quic.go | 4 ++-- internal/mocks/quic_test.go | 12 +++++++----- internal/netxlite/quic.go | 2 +- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/internal/measurex/quic.go b/internal/measurex/quic.go index d53bd80eea..51f64e47a2 100644 --- a/internal/measurex/quic.go +++ b/internal/measurex/quic.go @@ -118,7 +118,7 @@ func (qh *quicDialerDB) DialContext(ctx context.Context, address string, defer dialer.CloseIdleConnections() sess, err := dialer.DialContext(ctx, address, tlsConfig, quicConfig) if err == nil { - <-sess.HandshakeComplete().Done() // robustness (the dialer already does that) + <-sess.HandshakeComplete() // robustness (the dialer already does that) state = sess.ConnectionState().TLS.ConnectionState } finished := time.Since(qh.begin).Seconds() diff --git a/internal/mocks/quic.go b/internal/mocks/quic.go index 3e90d54d09..c99a6e0511 100644 --- a/internal/mocks/quic.go +++ b/internal/mocks/quic.go @@ -57,7 +57,7 @@ type QUICEarlyConnection struct { MockCloseWithError func(code quic.ApplicationErrorCode, reason string) error MockContext func() context.Context MockConnectionState func() quic.ConnectionState - MockHandshakeComplete func() context.Context + MockHandshakeComplete func() <-chan struct{} MockNextConnection func() quic.Connection MockSendMessage func(b []byte) error MockReceiveMessage func() ([]byte, error) @@ -122,7 +122,7 @@ func (s *QUICEarlyConnection) ConnectionState() quic.ConnectionState { } // HandshakeComplete calls MockHandshakeComplete. -func (s *QUICEarlyConnection) HandshakeComplete() context.Context { +func (s *QUICEarlyConnection) HandshakeComplete() <-chan struct{} { return s.MockHandshakeComplete() } diff --git a/internal/mocks/quic_test.go b/internal/mocks/quic_test.go index d275448208..ca09e9100f 100644 --- a/internal/mocks/quic_test.go +++ b/internal/mocks/quic_test.go @@ -233,15 +233,17 @@ func TestQUICEarlyConnection(t *testing.T) { }) t.Run("HandshakeComplete", func(t *testing.T) { - ctx := context.Background() + closedChan := make(chan struct{}) + close(closedChan) + var closedChanUni <-chan struct{} = closedChan // cast channel to unicast qconn := &QUICEarlyConnection{ - MockHandshakeComplete: func() context.Context { - return ctx + MockHandshakeComplete: func() <-chan struct{} { + return closedChanUni }, } out := qconn.HandshakeComplete() - if !reflect.DeepEqual(ctx, out) { - t.Fatal("not the context we expected") + if !reflect.DeepEqual(closedChanUni, out) { + t.Fatal("not the channel we expected") } }) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index b4fdf1f42a..c92171a5c5 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -211,7 +211,7 @@ func (d *quicDialerHandshakeCompleter) DialContext( return nil, err } select { - case <-conn.HandshakeComplete().Done(): + case <-conn.HandshakeComplete(): return conn, nil case <-ctx.Done(): conn.CloseWithError(0, "") // we own the conn From 734b65ef6cfd1876f004e98bc72455635c8cdcf2 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 13:48:07 +0200 Subject: [PATCH 03/16] (API change): replace DialEarlyContext with DialEarly --- internal/netxlite/quic.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index c92171a5c5..8ac4f6da7b 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -166,8 +166,8 @@ func (d *quicDialerQUICGo) dialEarlyContext(ctx context.Context, return d.mockDialEarlyContext( ctx, pconn, remoteAddr, address, tlsConfig, quicConfig) } - return quic.DialEarlyContext( - ctx, pconn, remoteAddr, address, tlsConfig, quicConfig) + return quic.DialEarly( + ctx, pconn, remoteAddr, tlsConfig, quicConfig) } // maybeApplyTLSDefaults ensures that we're using our certificate pool, if From 2ce5cf6cf47e3937a5e172457f4e267621f192b3 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 15:27:12 +0200 Subject: [PATCH 04/16] fix (change from v0.34.0): HandshakeComplete: use ctx.Done() as return --- internal/mocks/quic_test.go | 8 +++----- internal/netxlite/quic_test.go | 8 ++++---- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/internal/mocks/quic_test.go b/internal/mocks/quic_test.go index ca09e9100f..2d1ccecf13 100644 --- a/internal/mocks/quic_test.go +++ b/internal/mocks/quic_test.go @@ -233,16 +233,14 @@ func TestQUICEarlyConnection(t *testing.T) { }) t.Run("HandshakeComplete", func(t *testing.T) { - closedChan := make(chan struct{}) - close(closedChan) - var closedChanUni <-chan struct{} = closedChan // cast channel to unicast + ctx := context.Background() qconn := &QUICEarlyConnection{ MockHandshakeComplete: func() <-chan struct{} { - return closedChanUni + return ctx.Done() }, } out := qconn.HandshakeComplete() - if !reflect.DeepEqual(closedChanUni, out) { + if !reflect.DeepEqual(ctx.Done(), out) { t.Fatal("not the channel we expected") } }) diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index fd7911950a..ab3c9bc0c9 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -358,9 +358,9 @@ func TestQUICDialerHandshakeCompleter(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) var called bool expected := &mocks.QUICEarlyConnection{ - MockHandshakeComplete: func() context.Context { + MockHandshakeComplete: func() <-chan struct{} { cancel() - return handshakeCtx + return handshakeCtx.Done() }, MockCloseWithError: func(code quic.ApplicationErrorCode, reason string) error { called = true @@ -391,9 +391,9 @@ func TestQUICDialerHandshakeCompleter(t *testing.T) { handshakeCtx, handshakeCancel := context.WithCancel(context.Background()) defer handshakeCancel() expected := &mocks.QUICEarlyConnection{ - MockHandshakeComplete: func() context.Context { + MockHandshakeComplete: func() <-chan struct{} { handshakeCancel() - return handshakeCtx + return handshakeCtx.Done() }, } d := &quicDialerHandshakeCompleter{ From 07ada0e6a40dc709a53f4a61ef102622e42a0c45 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 15:28:05 +0200 Subject: [PATCH 05/16] (API change): replace Listener interface with pointer to struct --- internal/experiment/simplequicping/simplequicping_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/experiment/simplequicping/simplequicping_test.go b/internal/experiment/simplequicping/simplequicping_test.go index 8d833fbc12..c9ba65b3e9 100644 --- a/internal/experiment/simplequicping/simplequicping_test.go +++ b/internal/experiment/simplequicping/simplequicping_test.go @@ -132,7 +132,7 @@ func TestMeasurer_run(t *testing.T) { // SPDX-License-Identifier: MIT // // See https://github.com/quic-go/quic-go/blob/v0.27.0/example/echo/echo.go#L34 -func startEchoServer() (string, quic.Listener, error) { +func startEchoServer() (string, *quic.Listener, error) { listener, err := quic.ListenAddr("127.0.0.1:0", generateTLSConfig(), nil) if err != nil { return "", nil, err @@ -151,7 +151,7 @@ func startEchoServer() (string, quic.Listener, error) { // SPDX-License-Identifier: MIT // // See https://github.com/quic-go/quic-go/blob/v0.27.0/example/echo/echo.go#L34 -func echoWorkerMain(listener quic.Listener) { +func echoWorkerMain(listener *quic.Listener) { for { conn, err := listener.Accept(context.Background()) if err != nil { From 188de7f9dbc2ebbf303f522ea2f8c8e38013107f Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 15:40:59 +0200 Subject: [PATCH 06/16] (API change): replace name mockDialEarlyContext --- internal/netxlite/quic.go | 12 ++++++------ internal/netxlite/quic_test.go | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index 8ac4f6da7b..31b9f43969 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -89,8 +89,8 @@ type quicDialerQUICGo struct { // QUICListener is the underlying QUICListener to use. QUICListener model.QUICListener - // mockDialEarlyContext allows to mock quic.DialEarlyContext. - mockDialEarlyContext func(ctx context.Context, pconn net.PacketConn, + // mockDialEarly allows to mock quic.DialEarly. + mockDialEarly func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, host string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) } @@ -147,7 +147,7 @@ func (d *quicDialerQUICGo) DialContext(ctx context.Context, pconn = trace.MaybeWrapUDPLikeConn(pconn) started := trace.TimeNow() trace.OnQUICHandshakeStart(started, address, quicConfig) - qconn, err := d.dialEarlyContext( + qconn, err := d.dialEarly( ctx, pconn, udpAddr, address, tlsConfig, quicConfig) finished := trace.TimeNow() err = MaybeNewErrWrapper(ClassifyQUICHandshakeError, QUICHandshakeOperation, err) @@ -159,11 +159,11 @@ func (d *quicDialerQUICGo) DialContext(ctx context.Context, return newQUICConnectionOwnsConn(qconn, pconn), nil } -func (d *quicDialerQUICGo) dialEarlyContext(ctx context.Context, +func (d *quicDialerQUICGo) dialEarly(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, address string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { - if d.mockDialEarlyContext != nil { - return d.mockDialEarlyContext( + if d.mockDialEarly != nil { + return d.mockDialEarly( ctx, pconn, remoteAddr, address, tlsConfig, quicConfig) } return quic.DialEarly( diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index ab3c9bc0c9..c7808c14a6 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -229,7 +229,7 @@ func TestQUICDialerQUICGo(t *testing.T) { } systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, - mockDialEarlyContext: func(ctx context.Context, pconn net.PacketConn, + mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, host string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { gotTLSConfig = tlsConfig @@ -270,7 +270,7 @@ func TestQUICDialerQUICGo(t *testing.T) { } systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, - mockDialEarlyContext: func(ctx context.Context, pconn net.PacketConn, + mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, host string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { gotTLSConfig = tlsConfig @@ -310,7 +310,7 @@ func TestQUICDialerQUICGo(t *testing.T) { fakeconn := &mocks.QUICEarlyConnection{} systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, - mockDialEarlyContext: func(ctx context.Context, pconn net.PacketConn, + mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, host string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { return fakeconn, nil From 6ef4d335dcef633ab9b5ed3cd3d81649e0f15aaa Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 16:48:10 +0200 Subject: [PATCH 07/16] adapt mockDialEarly signature to quic.DialEarly --- internal/netxlite/quic.go | 4 ++-- internal/netxlite/quic_test.go | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index 31b9f43969..3ff96fea71 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -91,7 +91,7 @@ type quicDialerQUICGo struct { // mockDialEarly allows to mock quic.DialEarly. mockDialEarly func(ctx context.Context, pconn net.PacketConn, - remoteAddr net.Addr, host string, tlsConfig *tls.Config, + remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) } @@ -164,7 +164,7 @@ func (d *quicDialerQUICGo) dialEarly(ctx context.Context, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { if d.mockDialEarly != nil { return d.mockDialEarly( - ctx, pconn, remoteAddr, address, tlsConfig, quicConfig) + ctx, pconn, remoteAddr, tlsConfig, quicConfig) } return quic.DialEarly( ctx, pconn, remoteAddr, tlsConfig, quicConfig) diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index c7808c14a6..acddd8d5ce 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -230,7 +230,7 @@ func TestQUICDialerQUICGo(t *testing.T) { systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, - remoteAddr net.Addr, host string, tlsConfig *tls.Config, + remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { gotTLSConfig = tlsConfig return nil, expected @@ -271,7 +271,7 @@ func TestQUICDialerQUICGo(t *testing.T) { systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, - remoteAddr net.Addr, host string, tlsConfig *tls.Config, + remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { gotTLSConfig = tlsConfig return nil, expected @@ -311,7 +311,7 @@ func TestQUICDialerQUICGo(t *testing.T) { systemdialer := quicDialerQUICGo{ QUICListener: &quicListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, - remoteAddr net.Addr, host string, tlsConfig *tls.Config, + remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { return fakeconn, nil }, From 5adddeeef236331ea06a7f0ec9e4847d6dadf2c1 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Sun, 18 Jun 2023 19:39:52 +0200 Subject: [PATCH 08/16] dialEarly: remove unnecessary address parameter --- internal/netxlite/quic.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index 3ff96fea71..dd81427450 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -147,8 +147,7 @@ func (d *quicDialerQUICGo) DialContext(ctx context.Context, pconn = trace.MaybeWrapUDPLikeConn(pconn) started := trace.TimeNow() trace.OnQUICHandshakeStart(started, address, quicConfig) - qconn, err := d.dialEarly( - ctx, pconn, udpAddr, address, tlsConfig, quicConfig) + qconn, err := d.dialEarly(ctx, pconn, udpAddr, tlsConfig, quicConfig) finished := trace.TimeNow() err = MaybeNewErrWrapper(ClassifyQUICHandshakeError, QUICHandshakeOperation, err) trace.OnQUICHandshakeDone(started, address, qconn, tlsConfig, err, finished) @@ -160,7 +159,7 @@ func (d *quicDialerQUICGo) DialContext(ctx context.Context, } func (d *quicDialerQUICGo) dialEarly(ctx context.Context, - pconn net.PacketConn, remoteAddr net.Addr, address string, + pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { if d.mockDialEarly != nil { return d.mockDialEarly( From 762aef6a018dcdb76c8eef3ef520f9cbbba7a66a Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Mon, 19 Jun 2023 12:56:56 +0200 Subject: [PATCH 09/16] rename QUICListener to UDPListener --- internal/measurex/quic.go | 10 +++++----- internal/measurexlite/quic.go | 2 +- internal/measurexlite/quic_test.go | 6 +++--- internal/measurexlite/trace.go | 4 ++-- internal/measurexlite/trace_test.go | 2 +- internal/model/netx.go | 4 ++-- internal/netxlite/quic.go | 14 +++++++------- internal/tracex/quic.go | 6 +++--- 8 files changed, 24 insertions(+), 24 deletions(-) diff --git a/internal/measurex/quic.go b/internal/measurex/quic.go index 51f64e47a2..738e5f6186 100644 --- a/internal/measurex/quic.go +++ b/internal/measurex/quic.go @@ -18,13 +18,13 @@ import ( ) type quicListenerDB struct { - model.QUICListener + model.UDPListener begin time.Time db WritableDB } func (ql *quicListenerDB) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { - pconn, err := ql.QUICListener.Listen(addr) + pconn, err := ql.UDPListener.Listen(addr) if err != nil { return nil, err } @@ -110,9 +110,9 @@ func (qh *quicDialerDB) DialContext(ctx context.Context, address string, started := time.Since(qh.begin).Seconds() var state tls.ConnectionState listener := &quicListenerDB{ - QUICListener: netxlite.NewQUICListener(), - begin: qh.begin, - db: qh.db, + UDPListener: netxlite.NewQUICListener(), + begin: qh.begin, + db: qh.db, } dialer := netxlite.NewQUICDialerWithoutResolver(listener, qh.logger) defer dialer.CloseIdleConnections() diff --git a/internal/measurexlite/quic.go b/internal/measurexlite/quic.go index bbec9758a1..2896133953 100644 --- a/internal/measurexlite/quic.go +++ b/internal/measurexlite/quic.go @@ -16,7 +16,7 @@ import ( // NewQUICDialerWithoutResolver is equivalent to netxlite.NewQUICDialerWithoutResolver // except that it returns a model.QUICDialer that uses this trace. -func (tx *Trace) NewQUICDialerWithoutResolver(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { +func (tx *Trace) NewQUICDialerWithoutResolver(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return &quicDialerTrace{ qd: tx.newQUICDialerWithoutResolver(listener, dl), tx: tx, diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index daebfca9e6..3ae05b3c7d 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -23,7 +23,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { underlying := &mocks.QUICDialer{} zeroTime := time.Now() trace := NewTrace(0, zeroTime) - trace.newQUICDialerWithoutResolverFn = func(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { + trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } listener := &mocks.QUICListener{} @@ -50,7 +50,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { return nil, expectedErr }, } - trace.newQUICDialerWithoutResolverFn = func(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { + trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } listener := &mocks.QUICListener{} @@ -77,7 +77,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { called = true }, } - trace.newQUICDialerWithoutResolverFn = func(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { + trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } listener := &mocks.QUICListener{} diff --git a/internal/measurexlite/trace.go b/internal/measurexlite/trace.go index 8ab0bddbbe..7b1aa6bcbb 100644 --- a/internal/measurexlite/trace.go +++ b/internal/measurexlite/trace.go @@ -58,7 +58,7 @@ type Trace struct { // NewDialerWithoutResolverFn is OPTIONAL and can be used to override // calls to the netxlite.NewQUICDialerWithoutResolver factory. - newQUICDialerWithoutResolverFn func(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer + newQUICDialerWithoutResolverFn func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer // dnsLookup is MANDATORY and buffers DNS Lookup observations. dnsLookup chan *model.ArchivalDNSLookupResult @@ -224,7 +224,7 @@ func (tx *Trace) newTLSHandshakerUTLS(dl model.DebugLogger, id *utls.ClientHello // newQUICDialerWithoutResolver indirectly calls netxlite.NewQUICDialerWithoutResolver // thus allowing us to mock this func for testing. -func (tx *Trace) newQUICDialerWithoutResolver(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { +func (tx *Trace) newQUICDialerWithoutResolver(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { if tx.newQUICDialerWithoutResolverFn != nil { return tx.newQUICDialerWithoutResolverFn(listener, dl) } diff --git a/internal/measurexlite/trace_test.go b/internal/measurexlite/trace_test.go index bbcb46096a..0fc0adb11d 100644 --- a/internal/measurexlite/trace_test.go +++ b/internal/measurexlite/trace_test.go @@ -508,7 +508,7 @@ func TestTrace(t *testing.T) { t.Run("when not nil", func(t *testing.T) { mockedErr := errors.New("mocked") tx := &Trace{ - newQUICDialerWithoutResolverFn: func(listener model.QUICListener, dl model.DebugLogger) model.QUICDialer { + newQUICDialerWithoutResolverFn: func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return &mocks.QUICDialer{ MockDialContext: func(ctx context.Context, address string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { diff --git a/internal/model/netx.go b/internal/model/netx.go index 65bbeb8f32..8156b0bcad 100644 --- a/internal/model/netx.go +++ b/internal/model/netx.go @@ -181,8 +181,8 @@ type HTTPSSvc struct { IPv6 []string } -// QUICListener listens for QUIC connections. -type QUICListener interface { +// UDPListener listens for connections over UDP, e.g. QUIC. +type UDPListener interface { // Listen creates a new listening UDPLikeConn. Listen(addr *net.UDPAddr) (UDPLikeConn, error) } diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index dd81427450..fd32485a69 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -18,14 +18,14 @@ import ( // NewQUICListener creates a new QUICListener using the standard // library to create listening UDP sockets. -func NewQUICListener() model.QUICListener { +func NewQUICListener() model.UDPListener { return &quicListenerErrWrapper{&quicListenerStdlib{}} } // quicListenerStdlib is a QUICListener using the standard library. type quicListenerStdlib struct{} -var _ model.QUICListener = &quicListenerStdlib{} +var _ model.UDPListener = &quicListenerStdlib{} // Listen implements QUICListener.Listen. func (qls *quicListenerStdlib) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { @@ -49,7 +49,7 @@ func (qls *quicListenerStdlib) Listen(addr *net.UDPAddr) (model.UDPLikeConn, err // Unlike the dialer returned by WrapDialer, this dialer MAY attempt // happy eyeballs, perform parallel dial attempts, and return an error // that aggregates all the errors that occurred. -func NewQUICDialerWithResolver(listener model.QUICListener, logger model.DebugLogger, +func NewQUICDialerWithResolver(listener model.UDPListener, logger model.DebugLogger, resolver model.Resolver, wrappers ...model.QUICDialerWrapper) (outDialer model.QUICDialer) { outDialer = &quicDialerErrWrapper{ QUICDialer: &quicDialerHandshakeCompleter{ @@ -79,7 +79,7 @@ func NewQUICDialerWithResolver(listener model.QUICListener, logger model.DebugLo // NewQUICDialerWithoutResolver is equivalent to calling NewQUICDialerWithResolver // with the resolver argument set to &NullResolver{}. -func NewQUICDialerWithoutResolver(listener model.QUICListener, +func NewQUICDialerWithoutResolver(listener model.UDPListener, logger model.DebugLogger, wrappers ...model.QUICDialerWrapper) model.QUICDialer { return NewQUICDialerWithResolver(listener, logger, &NullResolver{}, wrappers...) } @@ -87,7 +87,7 @@ func NewQUICDialerWithoutResolver(listener model.QUICListener, // quicDialerQUICGo dials using the quic-go/quic-go library. type quicDialerQUICGo struct { // QUICListener is the underlying QUICListener to use. - QUICListener model.QUICListener + QUICListener model.UDPListener // mockDialEarly allows to mock quic.DialEarly. mockDialEarly func(ctx context.Context, pconn net.PacketConn, @@ -387,10 +387,10 @@ func (s *quicDialerSingleUse) CloseIdleConnections() { // quicListenerErrWrapper is a QUICListener that wraps errors. type quicListenerErrWrapper struct { // QUICListener is the underlying listener. - QUICListener model.QUICListener + QUICListener model.UDPListener } -var _ model.QUICListener = &quicListenerErrWrapper{} +var _ model.UDPListener = &quicListenerErrWrapper{} // Listen implements QUICListener.Listen. func (qls *quicListenerErrWrapper) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { diff --git a/internal/tracex/quic.go b/internal/tracex/quic.go index faf684ac79..f21ef7c2ea 100644 --- a/internal/tracex/quic.go +++ b/internal/tracex/quic.go @@ -99,7 +99,7 @@ func quicConnectionState(sess quic.EarlyConnection) tls.ConnectionState { // QUICListenerSaver is a QUICListener that also implements saving events. type QUICListenerSaver struct { // QUICListener is the underlying QUICListener. - QUICListener model.QUICListener + QUICListener model.UDPListener // Saver is the underlying Saver. Saver *Saver @@ -110,7 +110,7 @@ type QUICListenerSaver struct { // // When this function is invoked on a nil Saver, it will directly return // the original QUICListener without any wrapping. -func (s *Saver) WrapQUICListener(ql model.QUICListener) model.QUICListener { +func (s *Saver) WrapQUICListener(ql model.UDPListener) model.UDPListener { if s == nil { return ql } @@ -184,5 +184,5 @@ func (c *quicPacketConnWrapper) safeAddrString(addr net.Addr) (out string) { } var _ model.QUICDialer = &QUICDialerSaver{} -var _ model.QUICListener = &QUICListenerSaver{} +var _ model.UDPListener = &QUICListenerSaver{} var _ model.UDPLikeConn = &quicPacketConnWrapper{} From 17aef9d70d1a7ff5b72ac9d0912540c9b5a712c2 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Mon, 19 Jun 2023 13:00:07 +0200 Subject: [PATCH 10/16] rename NewQUICListener to NewUDPListener --- internal/cmd/oohelperd/main.go | 2 +- internal/dslx/quic.go | 2 +- .../simplequicping/simplequicping.go | 2 +- internal/legacy/netx/quic.go | 2 +- internal/measurex/quic.go | 2 +- internal/measurexlite/quic_test.go | 2 +- internal/netxlite/http3.go | 4 ++-- internal/netxlite/integration_test.go | 6 ++--- internal/netxlite/quic.go | 16 +++++++------- internal/netxlite/quic_test.go | 22 +++++++++---------- internal/tutorial/netxlite/chapter04/main.go | 2 +- internal/tutorial/netxlite/chapter08/main.go | 2 +- 12 files changed, 32 insertions(+), 32 deletions(-) diff --git a/internal/cmd/oohelperd/main.go b/internal/cmd/oohelperd/main.go index 3d48afa401..6ed43ae177 100644 --- a/internal/cmd/oohelperd/main.go +++ b/internal/cmd/oohelperd/main.go @@ -154,7 +154,7 @@ func newHandler() *handler { }, NewQUICDialer: func(logger model.Logger) model.QUICDialer { return netxlite.NewQUICDialerWithoutResolver( - netxlite.NewQUICListener(), + netxlite.NewUDPListener(), logger, ) }, diff --git a/internal/dslx/quic.go b/internal/dslx/quic.go index e0677280b1..3420269668 100644 --- a/internal/dslx/quic.go +++ b/internal/dslx/quic.go @@ -97,7 +97,7 @@ func (f *quicHandshakeFunc) Apply( ) // setup - quicListener := netxlite.NewQUICListener() + quicListener := netxlite.NewUDPListener() quicDialer := f.dialer if quicDialer == nil { quicDialer = trace.NewQUICDialerWithoutResolver(quicListener, input.Logger) diff --git a/internal/experiment/simplequicping/simplequicping.go b/internal/experiment/simplequicping/simplequicping.go index 1e91a7281b..55f3b67d80 100644 --- a/internal/experiment/simplequicping/simplequicping.go +++ b/internal/experiment/simplequicping/simplequicping.go @@ -171,7 +171,7 @@ func (m *Measurer) quicHandshake(ctx context.Context, index int64, alpn := strings.Split(m.config.alpn(), " ") trace := measurexlite.NewTrace(index, zeroTime) ol := measurexlite.NewOperationLogger(logger, "SimpleQUICPing #%d %s %s %v", index, address, sni, alpn) - listener := netxlite.NewQUICListener() + listener := netxlite.NewUDPListener() dialer := trace.NewQUICDialerWithoutResolver(listener, logger) // See https://github.com/ooni/probe/issues/2413 to understand // why we're using nil to force netxlite to use the cached diff --git a/internal/legacy/netx/quic.go b/internal/legacy/netx/quic.go index e48de760d6..7fa06cedb2 100644 --- a/internal/legacy/netx/quic.go +++ b/internal/legacy/netx/quic.go @@ -16,7 +16,7 @@ func NewQUICDialer(config Config) model.QUICDialer { } // TODO(https://github.com/ooni/probe/issues/2121#issuecomment-1147424810): we // should count the bytes consumed by this QUIC dialer - ql := config.ReadWriteSaver.WrapQUICListener(netxlite.NewQUICListener()) + ql := config.ReadWriteSaver.WrapQUICListener(netxlite.NewUDPListener()) logger := model.ValidLoggerOrDefault(config.Logger) return netxlite.NewQUICDialerWithResolver(ql, logger, config.FullResolver, config.Saver) } diff --git a/internal/measurex/quic.go b/internal/measurex/quic.go index 738e5f6186..2533a3e902 100644 --- a/internal/measurex/quic.go +++ b/internal/measurex/quic.go @@ -110,7 +110,7 @@ func (qh *quicDialerDB) DialContext(ctx context.Context, address string, started := time.Since(qh.begin).Seconds() var state tls.ConnectionState listener := &quicListenerDB{ - UDPListener: netxlite.NewQUICListener(), + UDPListener: netxlite.NewUDPListener(), begin: qh.begin, db: qh.db, } diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index 3ae05b3c7d..5a493c884f 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -262,7 +262,7 @@ func TestOnQUICHandshakeDoneExtractsTheConnectionState(t *testing.T) { trace := NewTrace(0, time.Now()) // create a QUIC dialer - quicListener := netxlite.NewQUICListener() + quicListener := netxlite.NewUDPListener() quicDialer := trace.NewQUICDialerWithoutResolver(quicListener, model.DiscardLogger) // dial with the endpoint we use for testing diff --git a/internal/netxlite/http3.go b/internal/netxlite/http3.go index 92093062d1..dcc667bc87 100644 --- a/internal/netxlite/http3.go +++ b/internal/netxlite/http3.go @@ -65,7 +65,7 @@ func NewHTTP3Transport( // NewHTTP3TransportStdlib creates a new HTTPTransport using http3 that // uses standard functionality for everything but the logger. func NewHTTP3TransportStdlib(logger model.DebugLogger) model.HTTPTransport { - ql := NewQUICListener() + ql := NewUDPListener() reso := NewStdlibResolver(logger) qd := NewQUICDialerWithResolver(ql, logger, reso) return NewHTTP3Transport(logger, qd, nil) @@ -74,7 +74,7 @@ func NewHTTP3TransportStdlib(logger model.DebugLogger) model.HTTPTransport { // NewHTTPTransportWithResolver creates a new HTTPTransport using http3 // that uses the given logger and the given resolver. func NewHTTP3TransportWithResolver(logger model.DebugLogger, reso model.Resolver) model.HTTPTransport { - qd := NewQUICDialerWithResolver(NewQUICListener(), logger, reso) + qd := NewQUICDialerWithResolver(NewUDPListener(), logger, reso) return NewHTTP3Transport(logger, qd, nil) } diff --git a/internal/netxlite/integration_test.go b/internal/netxlite/integration_test.go index b241373129..a156d83673 100644 --- a/internal/netxlite/integration_test.go +++ b/internal/netxlite/integration_test.go @@ -483,7 +483,7 @@ func TestMeasureWithQUICDialer(t *testing.T) { // t.Run("on success", func(t *testing.T) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) defer d.CloseIdleConnections() ctx := context.Background() @@ -506,7 +506,7 @@ func TestMeasureWithQUICDialer(t *testing.T) { }) t.Run("on timeout", func(t *testing.T) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) defer d.CloseIdleConnections() ctx := context.Background() @@ -584,7 +584,7 @@ func TestHTTP3Transport(t *testing.T) { t.Run("works as intended", func(t *testing.T) { d := netxlite.NewQUICDialerWithResolver( - netxlite.NewQUICListener(), + netxlite.NewUDPListener(), log.Log, netxlite.NewStdlibResolver(log.Log), ) diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index fd32485a69..d3a888cf74 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -16,19 +16,19 @@ import ( "github.com/quic-go/quic-go" ) -// NewQUICListener creates a new QUICListener using the standard +// NewUDPListener creates a new UDPListener using the standard // library to create listening UDP sockets. -func NewQUICListener() model.UDPListener { - return &quicListenerErrWrapper{&quicListenerStdlib{}} +func NewUDPListener() model.UDPListener { + return &quicListenerErrWrapper{&udpListenerStdlib{}} } -// quicListenerStdlib is a QUICListener using the standard library. -type quicListenerStdlib struct{} +// udpListenerStdlib is a UDPListener using the standard library. +type udpListenerStdlib struct{} -var _ model.UDPListener = &quicListenerStdlib{} +var _ model.UDPListener = &udpListenerStdlib{} -// Listen implements QUICListener.Listen. -func (qls *quicListenerStdlib) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { +// Listen implements UDPListener.Listen. +func (qls *udpListenerStdlib) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { return tproxySingleton().ListenUDP("udp", addr) } diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index acddd8d5ce..12759e92da 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -17,9 +17,9 @@ import ( ) func TestNewQUICListener(t *testing.T) { - ql := NewQUICListener() + ql := NewUDPListener() qew := ql.(*quicListenerErrWrapper) - _ = qew.QUICListener.(*quicListenerStdlib) + _ = qew.QUICListener.(*udpListenerStdlib) } type extensionQUICDialerFirst struct { @@ -45,7 +45,7 @@ func (*quicDialerWrapperSecond) WrapQUICDialer(qd model.QUICDialer) model.QUICDi } func TestNewQUICDialer(t *testing.T) { - ql := NewQUICListener() + ql := NewUDPListener() extensions := []model.QUICDialerWrapper{ &quicDialerWrapperFirst{}, nil, // explicitly test for this documented case @@ -129,7 +129,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, } defer systemdialer.CloseIdleConnections() // just to see it running ctx := context.Background() @@ -148,7 +148,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, } ctx := context.Background() qconn, err := systemdialer.DialContext( @@ -166,7 +166,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, } ctx := context.Background() qconn, err := systemdialer.DialContext( @@ -207,7 +207,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, } ctx, cancel := context.WithCancel(context.Background()) cancel() // fail immediately @@ -228,7 +228,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -269,7 +269,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -309,7 +309,7 @@ func TestQUICDialerQUICGo(t *testing.T) { } fakeconn := &mocks.QUICEarlyConnection{} systemdialer := quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -525,7 +525,7 @@ func TestQUICDialerResolver(t *testing.T) { dialer := &quicDialerResolver{ Resolver: NewStdlibResolver(log.Log), Dialer: &quicDialerQUICGo{ - QUICListener: &quicListenerStdlib{}, + QUICListener: &udpListenerStdlib{}, }} qconn, err := dialer.DialContext( context.Background(), "8.8.4.4:x", diff --git a/internal/tutorial/netxlite/chapter04/main.go b/internal/tutorial/netxlite/chapter04/main.go index 4ba85bf58e..a574b34ef4 100644 --- a/internal/tutorial/netxlite/chapter04/main.go +++ b/internal/tutorial/netxlite/chapter04/main.go @@ -92,7 +92,7 @@ func main() { // ```Go func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { diff --git a/internal/tutorial/netxlite/chapter08/main.go b/internal/tutorial/netxlite/chapter08/main.go index efc582f1b0..8258c7dbbd 100644 --- a/internal/tutorial/netxlite/chapter08/main.go +++ b/internal/tutorial/netxlite/chapter08/main.go @@ -105,7 +105,7 @@ func main() { func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { From 35c1a526c6e4222889ac31797e4886b9514a6cf5 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Mon, 19 Jun 2023 18:20:51 +0200 Subject: [PATCH 11/16] (API change): Use different mocks.UDPLikeConn for concurrent tests --- internal/measurexlite/quic_test.go | 8 +++++++- internal/measurexlite/trace_test.go | 3 +++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index 5a493c884f..1a892edf4d 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -97,6 +97,9 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { pconn := &mocks.UDPLikeConn{ MockLocalAddr: func() net.Addr { return &net.UDPAddr{ + // quic-go does not allow the use of the same net.PacketConn for multiple "Dial" + // calls (unless a quic.Transport is used), so we have to make sure to mock local + // addresses with different ports, as tests run in parallel. Port: 0, } }, @@ -207,7 +210,10 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { pconn := &mocks.UDPLikeConn{ MockLocalAddr: func() net.Addr { return &net.UDPAddr{ - Port: 0, + // quic-go does not allow the use of the same net.PacketConn for multiple "Dial" + // calls (unless a quic.Transport is used), so we have to make sure to mock local + // addresses with different ports, as tests run in parallel. + Port: 1, } }, MockRemoteAddr: func() net.Addr { diff --git a/internal/measurexlite/trace_test.go b/internal/measurexlite/trace_test.go index 0fc0adb11d..d70afbde4f 100644 --- a/internal/measurexlite/trace_test.go +++ b/internal/measurexlite/trace_test.go @@ -536,6 +536,9 @@ func TestTrace(t *testing.T) { pconn := &mocks.UDPLikeConn{ MockLocalAddr: func() net.Addr { return &net.UDPAddr{ + // quic-go does not allow the use of the same net.PacketConn for multiple "Dial" + // calls (unless a quic.Transport is used), so we have to make sure to mock local + // addresses with different ports, as tests run in parallel. Port: 0, } }, From 508e925d418697852113cb06ae693a5eb08d007f Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Wed, 28 Jun 2023 08:58:54 +0200 Subject: [PATCH 12/16] update to quic-go v0.36.0 --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 9c2fd37a16..8d2537adc4 100644 --- a/go.mod +++ b/go.mod @@ -33,7 +33,7 @@ require ( github.com/pborman/getopt/v2 v2.1.0 github.com/pion/stun v0.6.0 github.com/pkg/errors v0.9.1 - github.com/quic-go/quic-go v0.35.1 + github.com/quic-go/quic-go v0.36.0 github.com/rogpeppe/go-internal v1.10.0 github.com/rubenv/sql-migrate v1.4.0 github.com/schollz/progressbar/v3 v3.13.1 diff --git a/go.sum b/go.sum index 058d0752c7..6b3e91cedd 100644 --- a/go.sum +++ b/go.sum @@ -796,6 +796,8 @@ github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA= github.com/quic-go/quic-go v0.35.1 h1:b0kzj6b/cQAf05cT0CkQubHM31wiA+xH3IBkxP62poo= github.com/quic-go/quic-go v0.35.1/go.mod h1:+4CVgVppm0FNjpG3UcX8Joi/frKOH7/ciD5yGcwOO1g= +github.com/quic-go/quic-go v0.36.0 h1:JIrO7p7Ug6hssFcARjWDiqS2RAKJHCiwPxBAA989rbI= +github.com/quic-go/quic-go v0.36.0/go.mod h1:zPetvwDlILVxt15n3hr3Gf/I3mDf7LpLKPhR4Ez0AZQ= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/refraction-networking/conjure v0.4.0 h1:YObJ+6L/MnupE82N2+3m93GMzlHjHSHe1ysIYDOpqug= github.com/refraction-networking/conjure v0.4.0/go.mod h1:7na+SFWdaTOToNoNrsJRIj4CIMwdGFZ4kwb/CO5Z0rQ= From d2a807c1767434ece45e16f879beb03bc12ffcf8 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Wed, 28 Jun 2023 09:09:32 +0200 Subject: [PATCH 13/16] rename all QUICListeners to UDPListeners --- internal/dslx/quic.go | 4 +-- internal/legacy/netx/quic.go | 2 +- internal/measurex/quic.go | 6 ++-- internal/measurexlite/quic_test.go | 14 ++++---- internal/measurexlite/trace_test.go | 4 +-- internal/mocks/quic.go | 6 ++-- internal/mocks/quic_test.go | 4 +-- internal/netxlite/http3_test.go | 4 +-- internal/netxlite/quic.go | 26 +++++++------- internal/netxlite/quic_test.go | 36 +++++++++---------- internal/tracex/quic.go | 28 +++++++-------- internal/tracex/quic_test.go | 12 +++---- .../tutorial/netxlite/chapter04/README.md | 2 +- .../tutorial/netxlite/chapter08/README.md | 2 +- 14 files changed, 75 insertions(+), 75 deletions(-) diff --git a/internal/dslx/quic.go b/internal/dslx/quic.go index 3420269668..70fefdb529 100644 --- a/internal/dslx/quic.go +++ b/internal/dslx/quic.go @@ -97,10 +97,10 @@ func (f *quicHandshakeFunc) Apply( ) // setup - quicListener := netxlite.NewUDPListener() + udpListener := netxlite.NewUDPListener() quicDialer := f.dialer if quicDialer == nil { - quicDialer = trace.NewQUICDialerWithoutResolver(quicListener, input.Logger) + quicDialer = trace.NewQUICDialerWithoutResolver(udpListener, input.Logger) } config := &tls.Config{ NextProtos: []string{"h3"}, diff --git a/internal/legacy/netx/quic.go b/internal/legacy/netx/quic.go index 7fa06cedb2..15ad905e66 100644 --- a/internal/legacy/netx/quic.go +++ b/internal/legacy/netx/quic.go @@ -16,7 +16,7 @@ func NewQUICDialer(config Config) model.QUICDialer { } // TODO(https://github.com/ooni/probe/issues/2121#issuecomment-1147424810): we // should count the bytes consumed by this QUIC dialer - ql := config.ReadWriteSaver.WrapQUICListener(netxlite.NewUDPListener()) + ql := config.ReadWriteSaver.WrapUDPListener(netxlite.NewUDPListener()) logger := model.ValidLoggerOrDefault(config.Logger) return netxlite.NewQUICDialerWithResolver(ql, logger, config.FullResolver, config.Saver) } diff --git a/internal/measurex/quic.go b/internal/measurex/quic.go index 2533a3e902..1ace71059b 100644 --- a/internal/measurex/quic.go +++ b/internal/measurex/quic.go @@ -17,13 +17,13 @@ import ( "github.com/quic-go/quic-go" ) -type quicListenerDB struct { +type udpListenerDB struct { model.UDPListener begin time.Time db WritableDB } -func (ql *quicListenerDB) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { +func (ql *udpListenerDB) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { pconn, err := ql.UDPListener.Listen(addr) if err != nil { return nil, err @@ -109,7 +109,7 @@ func (qh *quicDialerDB) DialContext(ctx context.Context, address string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { started := time.Since(qh.begin).Seconds() var state tls.ConnectionState - listener := &quicListenerDB{ + listener := &udpListenerDB{ UDPListener: netxlite.NewUDPListener(), begin: qh.begin, db: qh.db, diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index 1a892edf4d..676c495f03 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -26,7 +26,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } - listener := &mocks.QUICListener{} + listener := &mocks.UDPListener{} dialer := trace.NewQUICDialerWithoutResolver(listener, model.DiscardLogger) dt := dialer.(*quicDialerTrace) if dt.qd != underlying { @@ -53,7 +53,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } - listener := &mocks.QUICListener{} + listener := &mocks.UDPListener{} dialer := trace.NewQUICDialerWithoutResolver(listener, model.DiscardLogger) ctx := context.Background() conn, err := dialer.DialContext(ctx, "1.1.1.1:443", &tls.Config{}, &quic.Config{}) @@ -80,7 +80,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { trace.newQUICDialerWithoutResolverFn = func(listener model.UDPListener, dl model.DebugLogger) model.QUICDialer { return underlying } - listener := &mocks.QUICListener{} + listener := &mocks.UDPListener{} dialer := trace.NewQUICDialerWithoutResolver(listener, model.DiscardLogger) dialer.CloseIdleConnections() if !called { @@ -115,7 +115,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { return nil }, } - listener := &mocks.QUICListener{ + listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return pconn, nil }, @@ -228,7 +228,7 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { return nil }, } - listener := &mocks.QUICListener{ + listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return pconn, nil }, @@ -268,8 +268,8 @@ func TestOnQUICHandshakeDoneExtractsTheConnectionState(t *testing.T) { trace := NewTrace(0, time.Now()) // create a QUIC dialer - quicListener := netxlite.NewUDPListener() - quicDialer := trace.NewQUICDialerWithoutResolver(quicListener, model.DiscardLogger) + udpListener := netxlite.NewUDPListener() + quicDialer := trace.NewQUICDialerWithoutResolver(udpListener, model.DiscardLogger) // dial with the endpoint we use for testing quicConn, err := quicDialer.DialContext( diff --git a/internal/measurexlite/trace_test.go b/internal/measurexlite/trace_test.go index d70afbde4f..2da8b03bd3 100644 --- a/internal/measurexlite/trace_test.go +++ b/internal/measurexlite/trace_test.go @@ -517,7 +517,7 @@ func TestTrace(t *testing.T) { } }, } - qdx := tx.newQUICDialerWithoutResolver(&mocks.QUICListener{}, model.DiscardLogger) + qdx := tx.newQUICDialerWithoutResolver(&mocks.UDPListener{}, model.DiscardLogger) ctx := context.Background() qconn, err := qdx.DialContext(ctx, "1.1.1.1:443", &tls.Config{}, &quic.Config{}) if !errors.Is(err, mockedErr) { @@ -554,7 +554,7 @@ func TestTrace(t *testing.T) { return nil }, } - listener := &mocks.QUICListener{ + listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return pconn, nil }, diff --git a/internal/mocks/quic.go b/internal/mocks/quic.go index c99a6e0511..10efd7bb06 100644 --- a/internal/mocks/quic.go +++ b/internal/mocks/quic.go @@ -11,13 +11,13 @@ import ( "github.com/quic-go/quic-go" ) -// QUICListener is a mockable netxlite.QUICListener. -type QUICListener struct { +// UDPListener is a mockable netxlite.UDPListener. +type UDPListener struct { MockListen func(addr *net.UDPAddr) (model.UDPLikeConn, error) } // Listen calls MockListen. -func (ql *QUICListener) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { +func (ql *UDPListener) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { return ql.MockListen(addr) } diff --git a/internal/mocks/quic_test.go b/internal/mocks/quic_test.go index 2d1ccecf13..48db2a833d 100644 --- a/internal/mocks/quic_test.go +++ b/internal/mocks/quic_test.go @@ -15,10 +15,10 @@ import ( "github.com/quic-go/quic-go" ) -func TestQUICListenerListen(t *testing.T) { +func TestUDPListenerListen(t *testing.T) { t.Run("Listen", func(t *testing.T) { expected := errors.New("mocked error") - ql := &QUICListener{ + ql := &UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return nil, expected }, diff --git a/internal/netxlite/http3_test.go b/internal/netxlite/http3_test.go index 3f1038ab5d..7d7dbee4dc 100644 --- a/internal/netxlite/http3_test.go +++ b/internal/netxlite/http3_test.go @@ -162,7 +162,7 @@ func TestNewHTTP3ClientWithResolver(t *testing.T) { if dialerReso.Resolver != reso { t.Fatal("invalid resolver") } - if dialerQUICGo.QUICListener == nil { - t.Fatal("QUICListener should not be nil") + if dialerQUICGo.UDPListener == nil { + t.Fatal("UDPListener should not be nil") } } diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index d3a888cf74..a716ccc6b9 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -19,7 +19,7 @@ import ( // NewUDPListener creates a new UDPListener using the standard // library to create listening UDP sockets. func NewUDPListener() model.UDPListener { - return &quicListenerErrWrapper{&udpListenerStdlib{}} + return &udpListenerErrWrapper{&udpListenerStdlib{}} } // udpListenerStdlib is a UDPListener using the standard library. @@ -54,7 +54,7 @@ func NewQUICDialerWithResolver(listener model.UDPListener, logger model.DebugLog outDialer = &quicDialerErrWrapper{ QUICDialer: &quicDialerHandshakeCompleter{ Dialer: &quicDialerQUICGo{ - QUICListener: listener, + UDPListener: listener, }, }, } @@ -86,8 +86,8 @@ func NewQUICDialerWithoutResolver(listener model.UDPListener, // quicDialerQUICGo dials using the quic-go/quic-go library. type quicDialerQUICGo struct { - // QUICListener is the underlying QUICListener to use. - QUICListener model.UDPListener + // UDPListener is the underlying UDPListener to use. + UDPListener model.UDPListener // mockDialEarly allows to mock quic.DialEarly. mockDialEarly func(ctx context.Context, pconn net.PacketConn, @@ -138,7 +138,7 @@ func (d *quicDialerQUICGo) DialContext(ctx context.Context, if err != nil { return nil, err } - pconn, err := d.QUICListener.Listen(&net.UDPAddr{IP: net.IPv4zero, Port: 0, Zone: ""}) + pconn, err := d.UDPListener.Listen(&net.UDPAddr{IP: net.IPv4zero, Port: 0, Zone: ""}) if err != nil { return nil, err } @@ -384,17 +384,17 @@ func (s *quicDialerSingleUse) CloseIdleConnections() { // nothing to do } -// quicListenerErrWrapper is a QUICListener that wraps errors. -type quicListenerErrWrapper struct { - // QUICListener is the underlying listener. - QUICListener model.UDPListener +// udpListenerErrWrapper is a UDPListener that wraps errors. +type udpListenerErrWrapper struct { + // UDPListener is the underlying listener. + UDPListener model.UDPListener } -var _ model.UDPListener = &quicListenerErrWrapper{} +var _ model.UDPListener = &udpListenerErrWrapper{} -// Listen implements QUICListener.Listen. -func (qls *quicListenerErrWrapper) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { - pconn, err := qls.QUICListener.Listen(addr) +// Listen implements UDPListener.Listen. +func (qls *udpListenerErrWrapper) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { + pconn, err := qls.UDPListener.Listen(addr) if err != nil { return nil, NewErrWrapper(ClassifyGenericError, QUICListenOperation, err) } diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index 12759e92da..7e51925a24 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -16,10 +16,10 @@ import ( "github.com/quic-go/quic-go" ) -func TestNewQUICListener(t *testing.T) { +func TestNewUDPListener(t *testing.T) { ql := NewUDPListener() - qew := ql.(*quicListenerErrWrapper) - _ = qew.QUICListener.(*udpListenerStdlib) + qew := ql.(*udpListenerErrWrapper) + _ = qew.UDPListener.(*udpListenerStdlib) } type extensionQUICDialerFirst struct { @@ -69,7 +69,7 @@ func TestNewQUICDialer(t *testing.T) { errWrapper := ext1.QUICDialer.(*quicDialerErrWrapper) handshakeCompleter := errWrapper.QUICDialer.(*quicDialerHandshakeCompleter) base := handshakeCompleter.Dialer.(*quicDialerQUICGo) - if base.QUICListener != ql { + if base.UDPListener != ql { t.Fatal("invalid quic listener") } } @@ -129,7 +129,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, } defer systemdialer.CloseIdleConnections() // just to see it running ctx := context.Background() @@ -148,7 +148,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, } ctx := context.Background() qconn, err := systemdialer.DialContext( @@ -166,7 +166,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, } ctx := context.Background() qconn, err := systemdialer.DialContext( @@ -185,7 +185,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "www.google.com", } systemdialer := quicDialerQUICGo{ - QUICListener: &mocks.QUICListener{ + UDPListener: &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return nil, expected }, @@ -207,7 +207,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, } ctx, cancel := context.WithCancel(context.Background()) cancel() // fail immediately @@ -228,7 +228,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -269,7 +269,7 @@ func TestQUICDialerQUICGo(t *testing.T) { ServerName: "dns.google", } systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -309,7 +309,7 @@ func TestQUICDialerQUICGo(t *testing.T) { } fakeconn := &mocks.QUICEarlyConnection{} systemdialer := quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, mockDialEarly: func(ctx context.Context, pconn net.PacketConn, remoteAddr net.Addr, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -525,7 +525,7 @@ func TestQUICDialerResolver(t *testing.T) { dialer := &quicDialerResolver{ Resolver: NewStdlibResolver(log.Log), Dialer: &quicDialerQUICGo{ - QUICListener: &udpListenerStdlib{}, + UDPListener: &udpListenerStdlib{}, }} qconn, err := dialer.DialContext( context.Background(), "8.8.4.4:x", @@ -724,12 +724,12 @@ func TestNewSingleUseQUICDialer(t *testing.T) { } } -func TestQUICListenerErrWrapper(t *testing.T) { +func TestUDPListenerErrWrapper(t *testing.T) { t.Run("Listen", func(t *testing.T) { t.Run("on success", func(t *testing.T) { expectedConn := &mocks.UDPLikeConn{} - ql := &quicListenerErrWrapper{ - QUICListener: &mocks.QUICListener{ + ql := &udpListenerErrWrapper{ + UDPListener: &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return expectedConn, nil }, @@ -747,8 +747,8 @@ func TestQUICListenerErrWrapper(t *testing.T) { t.Run("on failure", func(t *testing.T) { expectedErr := io.EOF - ql := &quicListenerErrWrapper{ - QUICListener: &mocks.QUICListener{ + ql := &udpListenerErrWrapper{ + UDPListener: &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return nil, expectedErr }, diff --git a/internal/tracex/quic.go b/internal/tracex/quic.go index f21ef7c2ea..c550961c81 100644 --- a/internal/tracex/quic.go +++ b/internal/tracex/quic.go @@ -96,33 +96,33 @@ func quicConnectionState(sess quic.EarlyConnection) tls.ConnectionState { return sess.ConnectionState().TLS.ConnectionState } -// QUICListenerSaver is a QUICListener that also implements saving events. -type QUICListenerSaver struct { - // QUICListener is the underlying QUICListener. - QUICListener model.UDPListener +// UDPListenerSaver is a UDPListener that also implements saving events. +type UDPListenerSaver struct { + // UDPListener is the underlying UDPListener. + UDPListener model.UDPListener // Saver is the underlying Saver. Saver *Saver } -// WrapQUICListener wraps a model.QUICDialer with a QUICListenerSaver that will +// WrapUDPListener wraps a model.UDPDialer with a UDPListenerSaver that will // save the QUIC I/O packet conn events into this Saver. // // When this function is invoked on a nil Saver, it will directly return -// the original QUICListener without any wrapping. -func (s *Saver) WrapQUICListener(ql model.UDPListener) model.UDPListener { +// the original UDPListener without any wrapping. +func (s *Saver) WrapUDPListener(ql model.UDPListener) model.UDPListener { if s == nil { return ql } - return &QUICListenerSaver{ - QUICListener: ql, - Saver: s, + return &UDPListenerSaver{ + UDPListener: ql, + Saver: s, } } -// Listen implements QUICListener.Listen. -func (qls *QUICListenerSaver) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { - pconn, err := qls.QUICListener.Listen(addr) +// Listen implements UDPListener.Listen. +func (qls *UDPListenerSaver) Listen(addr *net.UDPAddr) (model.UDPLikeConn, error) { + pconn, err := qls.UDPListener.Listen(addr) if err != nil { return nil, err } @@ -184,5 +184,5 @@ func (c *quicPacketConnWrapper) safeAddrString(addr net.Addr) (out string) { } var _ model.QUICDialer = &QUICDialerSaver{} -var _ model.UDPListener = &QUICListenerSaver{} +var _ model.UDPListener = &UDPListenerSaver{} var _ model.UDPLikeConn = &quicPacketConnWrapper{} diff --git a/internal/tracex/quic_test.go b/internal/tracex/quic_test.go index 7afe85d15a..4722b45bd6 100644 --- a/internal/tracex/quic_test.go +++ b/internal/tracex/quic_test.go @@ -177,19 +177,19 @@ func TestQUICDialerSaver(t *testing.T) { }) } -func TestWrapQUICListener(t *testing.T) { +func TestWrapUDPListener(t *testing.T) { var saver *Saver - ql := &mocks.QUICListener{} - if saver.WrapQUICListener(ql) != ql { + ql := &mocks.UDPListener{} + if saver.WrapUDPListener(ql) != ql { t.Fatal("unexpected result") } } -func TestQUICListenerSaver(t *testing.T) { +func TestUDPListenerSaver(t *testing.T) { t.Run("on failure", func(t *testing.T) { expected := errors.New("mocked error") saver := &Saver{} - qls := saver.WrapQUICListener(&mocks.QUICListener{ + qls := saver.WrapUDPListener(&mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return nil, expected }, @@ -210,7 +210,7 @@ func TestQUICListenerSaver(t *testing.T) { t.Run("on success", func(t *testing.T) { saver := &Saver{} returnedConn := &mocks.UDPLikeConn{} - qls := saver.WrapQUICListener(&mocks.QUICListener{ + qls := saver.WrapUDPListener(&mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { return returnedConn, nil }, diff --git a/internal/tutorial/netxlite/chapter04/README.md b/internal/tutorial/netxlite/chapter04/README.md index 7cc4c74c73..4cd709b94b 100644 --- a/internal/tutorial/netxlite/chapter04/README.md +++ b/internal/tutorial/netxlite/chapter04/README.md @@ -91,7 +91,7 @@ in the next two chapters.) ```Go func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { diff --git a/internal/tutorial/netxlite/chapter08/README.md b/internal/tutorial/netxlite/chapter08/README.md index 77aa77ec01..027898cdd2 100644 --- a/internal/tutorial/netxlite/chapter08/README.md +++ b/internal/tutorial/netxlite/chapter08/README.md @@ -104,7 +104,7 @@ exactly like what we've seen in chapter04. func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewQUICListener() + ql := netxlite.NewUDPListener() d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { From 9e8887c693b4d5e231de552759e528c5691f240b Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Mon, 7 Aug 2023 21:54:11 +0200 Subject: [PATCH 14/16] upgrade to quic-go 0.37.3 --- go.mod | 4 ++-- go.sum | 4 ++++ internal/dslx/quic.go | 2 +- internal/measurex/quic.go | 2 +- internal/measurexlite/quic.go | 2 +- internal/measurexlite/quic_test.go | 6 ++++++ internal/measurexlite/trace_test.go | 3 +++ internal/mocks/quic.go | 6 +++--- internal/mocks/quic_test.go | 5 +++-- internal/tracex/quic.go | 2 +- internal/tracex/quic_test.go | 2 +- internal/tutorial/netxlite/chapter04/main.go | 2 +- internal/tutorial/netxlite/chapter08/main.go | 2 +- 13 files changed, 28 insertions(+), 14 deletions(-) diff --git a/go.mod b/go.mod index 8d2537adc4..e551cbd40a 100644 --- a/go.mod +++ b/go.mod @@ -33,7 +33,7 @@ require ( github.com/pborman/getopt/v2 v2.1.0 github.com/pion/stun v0.6.0 github.com/pkg/errors v0.9.1 - github.com/quic-go/quic-go v0.36.0 + github.com/quic-go/quic-go v0.37.3 github.com/rogpeppe/go-internal v1.10.0 github.com/rubenv/sql-migrate v1.4.0 github.com/schollz/progressbar/v3 v3.13.1 @@ -74,7 +74,7 @@ require ( github.com/pmezard/go-difflib v1.0.0 // indirect github.com/quic-go/qpack v0.4.0 // indirect github.com/quic-go/qtls-go1-19 v0.3.2 // indirect - github.com/quic-go/qtls-go1-20 v0.2.2 // indirect + github.com/quic-go/qtls-go1-20 v0.3.1 // indirect github.com/refraction-networking/conjure v0.4.0 // indirect github.com/rivo/uniseg v0.4.4 // indirect github.com/segmentio/fasthash v1.0.3 // indirect diff --git a/go.sum b/go.sum index 6b3e91cedd..5648354b18 100644 --- a/go.sum +++ b/go.sum @@ -792,12 +792,16 @@ github.com/quic-go/qtls-go1-19 v0.3.2 h1:tFxjCFcTQzK+oMxG6Zcvp4Dq8dx4yD3dDiIiyc8 github.com/quic-go/qtls-go1-19 v0.3.2/go.mod h1:ySOI96ew8lnoKPtSqx2BlI5wCpUVPT05RMAlajtnyOI= github.com/quic-go/qtls-go1-20 v0.2.2 h1:WLOPx6OY/hxtTxKV1Zrq20FtXtDEkeY00CGQm8GEa3E= github.com/quic-go/qtls-go1-20 v0.2.2/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM= +github.com/quic-go/qtls-go1-20 v0.3.1 h1:O4BLOM3hwfVF3AcktIylQXyl7Yi2iBNVy5QsV+ySxbg= +github.com/quic-go/qtls-go1-20 v0.3.1/go.mod h1:X9Nh97ZL80Z+bX/gUXMbipO6OxdiDi58b/fMC9mAL+k= github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y0= github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA= github.com/quic-go/quic-go v0.35.1 h1:b0kzj6b/cQAf05cT0CkQubHM31wiA+xH3IBkxP62poo= github.com/quic-go/quic-go v0.35.1/go.mod h1:+4CVgVppm0FNjpG3UcX8Joi/frKOH7/ciD5yGcwOO1g= github.com/quic-go/quic-go v0.36.0 h1:JIrO7p7Ug6hssFcARjWDiqS2RAKJHCiwPxBAA989rbI= github.com/quic-go/quic-go v0.36.0/go.mod h1:zPetvwDlILVxt15n3hr3Gf/I3mDf7LpLKPhR4Ez0AZQ= +github.com/quic-go/quic-go v0.37.3 h1:pkHH3xaMNUNAh6OtgEV/0K6Fz+YIJXhPzgd/ShiRDm4= +github.com/quic-go/quic-go v0.37.3/go.mod h1:YsbH1r4mSHPJcLF4k4zruUkLBqctEMBDR6VPvcYjIsU= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/refraction-networking/conjure v0.4.0 h1:YObJ+6L/MnupE82N2+3m93GMzlHjHSHe1ysIYDOpqug= github.com/refraction-networking/conjure v0.4.0/go.mod h1:7na+SFWdaTOToNoNrsJRIj4CIMwdGFZ4kwb/CO5Z0rQ= diff --git a/internal/dslx/quic.go b/internal/dslx/quic.go index 70fefdb529..16018b485f 100644 --- a/internal/dslx/quic.go +++ b/internal/dslx/quic.go @@ -119,7 +119,7 @@ func (f *quicHandshakeFunc) Apply( var tlsState tls.ConnectionState if quicConn != nil { closerConn = &quicCloserConn{quicConn} - tlsState = quicConn.ConnectionState().TLS.ConnectionState // only quicConn can be nil + tlsState = quicConn.ConnectionState().TLS // only quicConn can be nil } // possibly track established conn for late close diff --git a/internal/measurex/quic.go b/internal/measurex/quic.go index 1ace71059b..7fdcae0a17 100644 --- a/internal/measurex/quic.go +++ b/internal/measurex/quic.go @@ -119,7 +119,7 @@ func (qh *quicDialerDB) DialContext(ctx context.Context, address string, sess, err := dialer.DialContext(ctx, address, tlsConfig, quicConfig) if err == nil { <-sess.HandshakeComplete() // robustness (the dialer already does that) - state = sess.ConnectionState().TLS.ConnectionState + state = sess.ConnectionState().TLS } finished := time.Since(qh.begin).Seconds() qh.db.InsertIntoQUICHandshake(&QUICTLSHandshakeEvent{ diff --git a/internal/measurexlite/quic.go b/internal/measurexlite/quic.go index 2896133953..08bfa7d188 100644 --- a/internal/measurexlite/quic.go +++ b/internal/measurexlite/quic.go @@ -60,7 +60,7 @@ func (tx *Trace) OnQUICHandshakeDone(started time.Time, remoteAddr string, qconn state := tls.ConnectionState{} if qconn != nil { - state = qconn.ConnectionState().TLS.ConnectionState + state = qconn.ConnectionState().TLS } select { diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index 676c495f03..78083643e2 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -114,6 +114,9 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { MockClose: func() error { return nil }, + MockSetReadBuffer: func(n int) error { + return nil + }, } listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { @@ -227,6 +230,9 @@ func TestNewQUICDialerWithoutResolver(t *testing.T) { MockClose: func() error { return nil }, + MockSetReadBuffer: func(n int) error { + return nil + }, } listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { diff --git a/internal/measurexlite/trace_test.go b/internal/measurexlite/trace_test.go index 2da8b03bd3..e7950f93ad 100644 --- a/internal/measurexlite/trace_test.go +++ b/internal/measurexlite/trace_test.go @@ -553,6 +553,9 @@ func TestTrace(t *testing.T) { MockClose: func() error { return nil }, + MockSetReadBuffer: func(n int) error { + return nil + }, } listener := &mocks.UDPListener{ MockListen: func(addr *net.UDPAddr) (model.UDPLikeConn, error) { diff --git a/internal/mocks/quic.go b/internal/mocks/quic.go index 10efd7bb06..102bb2f1dd 100644 --- a/internal/mocks/quic.go +++ b/internal/mocks/quic.go @@ -60,7 +60,7 @@ type QUICEarlyConnection struct { MockHandshakeComplete func() <-chan struct{} MockNextConnection func() quic.Connection MockSendMessage func(b []byte) error - MockReceiveMessage func() ([]byte, error) + MockReceiveMessage func(ctx context.Context) ([]byte, error) } var _ quic.EarlyConnection = &QUICEarlyConnection{} @@ -137,8 +137,8 @@ func (s *QUICEarlyConnection) SendMessage(b []byte) error { } // ReceiveMessage calls MockReceiveMessage. -func (s *QUICEarlyConnection) ReceiveMessage() ([]byte, error) { - return s.MockReceiveMessage() +func (s *QUICEarlyConnection) ReceiveMessage(ctx context.Context) ([]byte, error) { + return s.MockReceiveMessage(ctx) } // UDPLikeConn is an UDP conn used by QUIC. diff --git a/internal/mocks/quic_test.go b/internal/mocks/quic_test.go index 48db2a833d..bb5505f437 100644 --- a/internal/mocks/quic_test.go +++ b/internal/mocks/quic_test.go @@ -274,12 +274,13 @@ func TestQUICEarlyConnection(t *testing.T) { t.Run("ReceiveMessage", func(t *testing.T) { expected := errors.New("mocked error") + ctx := context.Background() qconn := &QUICEarlyConnection{ - MockReceiveMessage: func() ([]byte, error) { + MockReceiveMessage: func(ctx context.Context) ([]byte, error) { return nil, expected }, } - b, err := qconn.ReceiveMessage() + b, err := qconn.ReceiveMessage(ctx) if !errors.Is(err, expected) { t.Fatal("not the error we expected", err) } diff --git a/internal/tracex/quic.go b/internal/tracex/quic.go index c550961c81..0d492685e7 100644 --- a/internal/tracex/quic.go +++ b/internal/tracex/quic.go @@ -93,7 +93,7 @@ func (h *QUICDialerSaver) CloseIdleConnections() { // quicConnectionState returns the ConnectionState of a QUIC Session. func quicConnectionState(sess quic.EarlyConnection) tls.ConnectionState { - return sess.ConnectionState().TLS.ConnectionState + return sess.ConnectionState().TLS } // UDPListenerSaver is a UDPListener that also implements saving events. diff --git a/internal/tracex/quic_test.go b/internal/tracex/quic_test.go index 4722b45bd6..7530b04ef7 100644 --- a/internal/tracex/quic_test.go +++ b/internal/tracex/quic_test.go @@ -81,7 +81,7 @@ func TestQUICDialerSaver(t *testing.T) { returnedConn := &mocks.QUICEarlyConnection{ MockConnectionState: func() quic.ConnectionState { cs := quic.ConnectionState{} - cs.TLS.ConnectionState.CipherSuite = tls.TLS_RSA_WITH_RC4_128_SHA + cs.TLS.CipherSuite = tls.TLS_RSA_WITH_RC4_128_SHA cs.TLS.NegotiatedProtocol = "h3" cs.TLS.PeerCertificates = []*x509.Certificate{{ Raw: []byte{1, 2, 3, 4}, diff --git a/internal/tutorial/netxlite/chapter04/main.go b/internal/tutorial/netxlite/chapter04/main.go index a574b34ef4..d1d649af77 100644 --- a/internal/tutorial/netxlite/chapter04/main.go +++ b/internal/tutorial/netxlite/chapter04/main.go @@ -105,7 +105,7 @@ func dialQUIC(ctx context.Context, address string, // we returned in the previous chapters. // // ```Go - return qconn, qconn.ConnectionState().TLS.ConnectionState, nil + return qconn, qconn.ConnectionState().TLS, nil } // ``` diff --git a/internal/tutorial/netxlite/chapter08/main.go b/internal/tutorial/netxlite/chapter08/main.go index 8258c7dbbd..d7cc0886e8 100644 --- a/internal/tutorial/netxlite/chapter08/main.go +++ b/internal/tutorial/netxlite/chapter08/main.go @@ -111,7 +111,7 @@ func dialQUIC(ctx context.Context, address string, if err != nil { return nil, tls.ConnectionState{}, err } - return qconn, qconn.ConnectionState().TLS.ConnectionState, nil + return qconn, qconn.ConnectionState().TLS, nil } func fatal(err error) { From c2787e23ee186a362c30be6abc5d660e8a9dc887 Mon Sep 17 00:00:00 2001 From: kelmenhorst Date: Tue, 22 Aug 2023 14:48:12 -0400 Subject: [PATCH 15/16] fix: updated function name NewUDPListener --- internal/oohelperd/handler.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/oohelperd/handler.go b/internal/oohelperd/handler.go index 15eda5435f..dac0cb2f5c 100644 --- a/internal/oohelperd/handler.go +++ b/internal/oohelperd/handler.go @@ -90,7 +90,7 @@ func NewHandler() *Handler { }, NewQUICDialer: func(logger model.Logger) model.QUICDialer { return netxlite.NewQUICDialerWithoutResolver( - netxlite.NewQUICListener(), + netxlite.NewUDPListener(), logger, ) }, From 0d31156972bfd89021e3da3342b51263660e5f12 Mon Sep 17 00:00:00 2001 From: Simone Basso Date: Thu, 7 Sep 2023 14:33:35 +0200 Subject: [PATCH 16/16] x --- internal/netxlite/quic_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index 5078c78965..33ba2d9e5d 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -346,7 +346,7 @@ func TestQUICDialerWithCustomUnderlyingNetwork(t *testing.T) { }, } systemdialer := &quicDialerQUICGo{ - UDPListener: &udpListenerStdlib{provider: &tproxyNilSafeProvider{proxy}}, + UDPListener: &udpListenerStdlib{provider: &MaybeCustomUnderlyingNetwork{proxy}}, } qconn, err := systemdialer.DialContext(ctx, "8.8.8.8:443", tlsConf, qConf) if qconn != nil {