From 70861a6cf219f276e5021e3018c6ca800cb5f873 Mon Sep 17 00:00:00 2001 From: Simone Basso Date: Wed, 24 Jan 2024 10:55:21 +0100 Subject: [PATCH] cleanup(netxlite): remove first-order implicit-Netx wrappers (#1465) This diff removes the first-order implicit-Netx wrappers. We define first-order implicit-Netx wrappers the top-level functions that have the same name of netxlite.Netx methods, allocate an empty Netx, and call the corresponding method. The reason why we're doing this now is that it has been relatively hard to implement https://github.com/ooni/probe-cli/pull/1464 because of the ambiguity between those first-order wrappers and the methods. Getting this wrong means that QA tests would behave in a funny way. The overall goal here is to refactor `oohelperd` to only depend on `netxlite.Netx` such that we can remove the code duplication between how we instantiate `oohelperd.Handler` in `oohelperd` and how we instantiate it inside `netemx`. In turn, by doing this, we would ensure we have the same `oohelperd` behavior for QA and production. In turn, with this guarantee, we can write QA tests that ensure we're correctly dealing with 127.0.0.1. The reference issue is https://github.com/ooni/probe/issues/1517. --- internal/cmd/apitool/main.go | 3 +- .../gardener/internal/dnsreport/dnsreport.go | 3 +- internal/cmd/oohelper/oohelper.go | 3 +- internal/cmd/ooporthelper/main_test.go | 3 +- internal/enginelocate/cloudflare_test.go | 3 +- internal/enginelocate/geolocate.go | 3 +- internal/enginelocate/iplookup_test.go | 9 +- internal/enginelocate/resolverlookup.go | 3 +- internal/enginelocate/stun.go | 3 +- internal/enginelocate/stun_test.go | 9 +- internal/enginelocate/ubuntu_test.go | 6 +- internal/enginenetx/httpsdialer_test.go | 3 +- internal/enginenetx/network.go | 7 +- internal/enginenetx/network_internal_test.go | 2 +- internal/enginenetx/network_test.go | 15 ++-- internal/enginenetx/statsmanager_test.go | 2 +- internal/engineresolver/factory.go | 8 +- internal/experiment/ndt7/dial.go | 5 +- .../simplequicping/simplequicping.go | 3 +- .../webconnectivitylte/dnsresolvers.go | 3 +- .../webconnectivitylte/dnswhoami.go | 6 +- .../webconnectivityqa/control_test.go | 6 +- .../webconnectivityqa/dnsblocking_test.go | 9 +- .../webconnectivityqa/dnshijacking_test.go | 8 +- .../webconnectivityqa/httpblocking_test.go | 3 +- .../webconnectivityqa/httpdiff_test.go | 8 +- .../webconnectivityqa/redirect_test.go | 11 ++- .../webconnectivityqa/tcpblocking_test.go | 6 +- .../webconnectivityqa/tlsblocking_test.go | 8 +- internal/legacy/measurex/dialer.go | 6 +- internal/legacy/measurex/measurer.go | 3 +- internal/legacy/measurex/quic.go | 5 +- internal/legacy/measurex/resolver.go | 3 +- internal/legacy/measurex/resolver_test.go | 6 +- internal/legacy/measurex/tls.go | 3 +- internal/legacy/measurex/tracing.go | 7 +- internal/legacy/netx/dialer.go | 3 +- internal/legacy/netx/quic.go | 5 +- internal/legacy/netx/tls.go | 3 +- internal/legacy/tracex/http_test.go | 3 +- internal/legacy/tracex/resolver_test.go | 6 +- internal/measurexlite/dialer.go | 2 +- internal/measurexlite/doc.go | 2 +- internal/measurexlite/quic.go | 2 +- internal/measurexlite/quic_test.go | 3 +- internal/measurexlite/tls.go | 2 +- internal/measurexlite/tls_test.go | 3 +- internal/measurexlite/trace_test.go | 3 +- internal/measurexlite/utls.go | 2 +- internal/netemx/android_test.go | 3 +- internal/netemx/badssl_test.go | 5 +- internal/netemx/dnsoverudp_test.go | 5 +- internal/netemx/example_test.go | 42 +++++---- internal/netemx/http3_test.go | 3 +- internal/netemx/qaenv_test.go | 6 +- internal/netxlite/dialer.go | 25 ++---- internal/netxlite/dialer_test.go | 3 +- internal/netxlite/dnsoverhttps_test.go | 3 +- internal/netxlite/dnsoverudp_test.go | 15 ++-- internal/netxlite/http3.go | 10 +-- internal/netxlite/http3_test.go | 3 +- internal/netxlite/httpquirks.go | 17 ++-- internal/netxlite/httpquirks_test.go | 8 +- internal/netxlite/integration_test.go | 90 ++++++++++++------- internal/netxlite/quic.go | 18 +--- internal/netxlite/quic_test.go | 17 ++-- internal/netxlite/resolvercore.go | 25 +----- internal/netxlite/resolvercore_test.go | 14 +-- internal/netxlite/tls.go | 7 -- internal/netxlite/tls_test.go | 9 +- internal/netxlite/udp.go | 7 -- internal/netxlite/udp_test.go | 3 +- internal/netxlite/utls.go | 7 -- internal/netxlite/utls_test.go | 3 +- internal/oohelperd/handler.go | 12 +-- internal/testingproxy/hosthttp.go | 2 +- internal/testingproxy/hosthttps.go | 2 +- internal/testingproxy/sockshost.go | 2 +- internal/testingx/httptestx_test.go | 10 ++- internal/testingx/tlsx_test.go | 10 ++- .../tutorial/netxlite/chapter01/README.md | 3 +- internal/tutorial/netxlite/chapter01/main.go | 3 +- .../tutorial/netxlite/chapter02/README.md | 6 +- internal/tutorial/netxlite/chapter02/main.go | 6 +- .../tutorial/netxlite/chapter03/README.md | 6 +- internal/tutorial/netxlite/chapter03/main.go | 6 +- .../tutorial/netxlite/chapter04/README.md | 5 +- internal/tutorial/netxlite/chapter04/main.go | 5 +- .../tutorial/netxlite/chapter05/README.md | 3 +- internal/tutorial/netxlite/chapter05/main.go | 3 +- .../tutorial/netxlite/chapter06/README.md | 5 +- internal/tutorial/netxlite/chapter06/main.go | 5 +- .../tutorial/netxlite/chapter07/README.md | 6 +- internal/tutorial/netxlite/chapter07/main.go | 6 +- .../tutorial/netxlite/chapter08/README.md | 5 +- internal/tutorial/netxlite/chapter08/main.go | 5 +- internal/x/dslvm/trace.go | 6 +- internal/x/dslx/quic_test.go | 3 +- internal/x/dslx/trace.go | 6 +- 99 files changed, 395 insertions(+), 317 deletions(-) diff --git a/internal/cmd/apitool/main.go b/internal/cmd/apitool/main.go index 1f8490171c..0b24e55f31 100644 --- a/internal/cmd/apitool/main.go +++ b/internal/cmd/apitool/main.go @@ -28,7 +28,8 @@ import ( func newclient() probeservices.Client { // TODO(https://github.com/ooni/probe/issues/2534): NewHTTPTransportStdlib has QUIRKS but we // don't actually care about those QUIRKS in this context - txp := netxlite.NewHTTPTransportStdlib(log.Log) + netx := &netxlite.Netx{} + txp := netx.NewHTTPTransportStdlib(log.Log) ua := fmt.Sprintf("apitool/%s ooniprobe-engine/%s", version.Version, version.Version) return probeservices.Client{ APIClientTemplate: httpx.APIClientTemplate{ diff --git a/internal/cmd/gardener/internal/dnsreport/dnsreport.go b/internal/cmd/gardener/internal/dnsreport/dnsreport.go index 4d47b02249..daa5fb7229 100644 --- a/internal/cmd/gardener/internal/dnsreport/dnsreport.go +++ b/internal/cmd/gardener/internal/dnsreport/dnsreport.go @@ -253,7 +253,8 @@ func (s *Subcommand) dnsLookupHost(domain string) ([]string, error) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() - dnsResolver := netxlite.NewParallelDNSOverHTTPSResolver(log.Log, s.DNSOverHTTPSServerURL) + netx := &netxlite.Netx{} + dnsResolver := netx.NewParallelDNSOverHTTPSResolver(log.Log, s.DNSOverHTTPSServerURL) defer dnsResolver.CloseIdleConnections() // lookup for both A and AAAA entries diff --git a/internal/cmd/oohelper/oohelper.go b/internal/cmd/oohelper/oohelper.go index a10a5ad886..37dbe27a04 100644 --- a/internal/cmd/oohelper/oohelper.go +++ b/internal/cmd/oohelper/oohelper.go @@ -28,7 +28,8 @@ func init() { // Use a nonstandard resolver, which is enough to work around the // puzzling https://github.com/ooni/probe/issues/1409 issue. const resolverURL = "https://8.8.8.8/dns-query" - resolver = netxlite.NewParallelDNSOverHTTPSResolver(log.Log, resolverURL) + netx := &netxlite.Netx{} + resolver = netx.NewParallelDNSOverHTTPSResolver(log.Log, resolverURL) // TODO(https://github.com/ooni/probe/issues/2534): the NewHTTPClientWithResolver func has QUIRKS but we don't care. httpClient = netxlite.NewHTTPClientWithResolver(log.Log, resolver) } diff --git a/internal/cmd/ooporthelper/main_test.go b/internal/cmd/ooporthelper/main_test.go index 6c41a7ad3a..c5378c018d 100644 --- a/internal/cmd/ooporthelper/main_test.go +++ b/internal/cmd/ooporthelper/main_test.go @@ -19,7 +19,8 @@ func TestMainWorkingAsIntended(t *testing.T) { portsMap[port] = false } go main() - dialer := netxlite.NewDialerWithoutResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) for i := 0; i < len(TestPorts); i++ { port := <-srvTestChan addr := net.JoinHostPort("127.0.0.1", port) diff --git a/internal/enginelocate/cloudflare_test.go b/internal/enginelocate/cloudflare_test.go index 4fc62e5197..ff49ce9957 100644 --- a/internal/enginelocate/cloudflare_test.go +++ b/internal/enginelocate/cloudflare_test.go @@ -16,12 +16,13 @@ func TestIPLookupWorksUsingcloudlflare(t *testing.T) { t.Skip("skip test in short mode") } + netx := &netxlite.Netx{} ip, err := cloudflareIPLookup( context.Background(), http.DefaultClient, log.Log, model.HTTPHeaderUserAgent, - netxlite.NewStdlibResolver(model.DiscardLogger), + netx.NewStdlibResolver(model.DiscardLogger), ) if err != nil { t.Fatal(err) diff --git a/internal/enginelocate/geolocate.go b/internal/enginelocate/geolocate.go index ce3d282667..217f4ba309 100644 --- a/internal/enginelocate/geolocate.go +++ b/internal/enginelocate/geolocate.go @@ -82,8 +82,9 @@ func NewTask(config Config) *Task { if config.UserAgent == "" { config.UserAgent = fmt.Sprintf("ooniprobe-engine/%s", version.Version) } + netx := &netxlite.Netx{} if config.Resolver == nil { - config.Resolver = netxlite.NewStdlibResolver(config.Logger) + config.Resolver = netx.NewStdlibResolver(config.Logger) } return &Task{ countryLookupper: mmdbLookupper{}, diff --git a/internal/enginelocate/iplookup_test.go b/internal/enginelocate/iplookup_test.go index 650c0eefd8..8af1a549a2 100644 --- a/internal/enginelocate/iplookup_test.go +++ b/internal/enginelocate/iplookup_test.go @@ -17,9 +17,10 @@ func TestIPLookupGood(t *testing.T) { t.Skip("skip test in short mode") } + netx := &netxlite.Netx{} ip, err := (ipLookupClient{ Logger: log.Log, - Resolver: netxlite.NewStdlibResolver(model.DiscardLogger), + Resolver: netx.NewStdlibResolver(model.DiscardLogger), UserAgent: "ooniprobe-engine/0.1.0", }).LookupProbeIP(context.Background()) if err != nil { @@ -33,9 +34,10 @@ func TestIPLookupGood(t *testing.T) { func TestIPLookupAllFailed(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() // immediately cancel to cause Do() to fail + netx := &netxlite.Netx{} ip, err := (ipLookupClient{ Logger: log.Log, - Resolver: netxlite.NewStdlibResolver(model.DiscardLogger), + Resolver: netx.NewStdlibResolver(model.DiscardLogger), UserAgent: "ooniprobe-engine/0.1.0", }).LookupProbeIP(ctx) if !errors.Is(err, context.Canceled) { @@ -48,9 +50,10 @@ func TestIPLookupAllFailed(t *testing.T) { func TestIPLookupInvalidIP(t *testing.T) { ctx := context.Background() + netx := &netxlite.Netx{} ip, err := (ipLookupClient{ Logger: log.Log, - Resolver: netxlite.NewStdlibResolver(model.DiscardLogger), + Resolver: netx.NewStdlibResolver(model.DiscardLogger), UserAgent: "ooniprobe-engine/0.1.0", }).doWithCustomFunc(ctx, invalidIPLookup) if !errors.Is(err, ErrInvalidIPAddress) { diff --git a/internal/enginelocate/resolverlookup.go b/internal/enginelocate/resolverlookup.go index fe93b2a21e..f07e37d579 100644 --- a/internal/enginelocate/resolverlookup.go +++ b/internal/enginelocate/resolverlookup.go @@ -14,7 +14,8 @@ type resolverLookupClient struct { func (rlc resolverLookupClient) LookupResolverIP(ctx context.Context) (string, error) { // MUST be the system resolver! See https://github.com/ooni/probe/issues/2360 - reso := netxlite.NewStdlibResolver(rlc.Logger) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(rlc.Logger) var ips []string ips, err := reso.LookupHost(ctx, "whoami.v4.powerdns.org") if err != nil { diff --git a/internal/enginelocate/stun.go b/internal/enginelocate/stun.go index 848e29a83d..b001401a96 100644 --- a/internal/enginelocate/stun.go +++ b/internal/enginelocate/stun.go @@ -33,7 +33,8 @@ func stunIPLookup(ctx context.Context, config stunConfig) (string, error) { ip, err := func() (string, error) { dialer := config.Dialer if dialer == nil { - dialer = netxlite.NewDialerWithResolver(config.Logger, config.Resolver) + netx := &netxlite.Netx{} + dialer = netx.NewDialerWithResolver(config.Logger, config.Resolver) } conn, err := dialer.DialContext(ctx, "udp", config.Endpoint) if err != nil { diff --git a/internal/enginelocate/stun_test.go b/internal/enginelocate/stun_test.go index d6a0707cd6..ba5562bb5c 100644 --- a/internal/enginelocate/stun_test.go +++ b/internal/enginelocate/stun_test.go @@ -18,10 +18,11 @@ import ( func TestSTUNIPLookupCanceledContext(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() // stop immediately + netx := &netxlite.Netx{} ip, err := stunIPLookup(ctx, stunConfig{ Endpoint: "stun.ekiga.net:3478", Logger: log.Log, - Resolver: netxlite.NewStdlibResolver(model.DiscardLogger), + Resolver: netx.NewStdlibResolver(model.DiscardLogger), }) if !errors.Is(err, context.Canceled) { t.Fatalf("not the error we expected: %+v", err) @@ -151,12 +152,13 @@ func TestIPLookupWorksUsingSTUNEkiga(t *testing.T) { t.Skip("skip test in short mode") } + netx := &netxlite.Netx{} ip, err := stunEkigaIPLookup( context.Background(), http.DefaultClient, log.Log, model.HTTPHeaderUserAgent, - netxlite.NewStdlibResolver(model.DiscardLogger), + netx.NewStdlibResolver(model.DiscardLogger), ) if err != nil { t.Fatal(err) @@ -171,12 +173,13 @@ func TestIPLookupWorksUsingSTUNGoogle(t *testing.T) { t.Skip("skip test in short mode") } + netx := &netxlite.Netx{} ip, err := stunGoogleIPLookup( context.Background(), http.DefaultClient, log.Log, model.HTTPHeaderUserAgent, - netxlite.NewStdlibResolver(model.DiscardLogger), + netx.NewStdlibResolver(model.DiscardLogger), ) if err != nil { t.Fatal(err) diff --git a/internal/enginelocate/ubuntu_test.go b/internal/enginelocate/ubuntu_test.go index b2ede1f07e..e4e313484b 100644 --- a/internal/enginelocate/ubuntu_test.go +++ b/internal/enginelocate/ubuntu_test.go @@ -14,6 +14,7 @@ import ( ) func TestUbuntuParseError(t *testing.T) { + netx := &netxlite.Netx{} ip, err := ubuntuIPLookup( context.Background(), &http.Client{Transport: FakeTransport{ @@ -24,7 +25,7 @@ func TestUbuntuParseError(t *testing.T) { }}, log.Log, model.HTTPHeaderUserAgent, - netxlite.NewStdlibResolver(model.DiscardLogger), + netx.NewStdlibResolver(model.DiscardLogger), ) if err == nil || !strings.HasPrefix(err.Error(), "XML syntax error") { t.Fatalf("not the error we expected: %+v", err) @@ -39,12 +40,13 @@ func TestIPLookupWorksUsingUbuntu(t *testing.T) { t.Skip("skip test in short mode") } + netx := &netxlite.Netx{} ip, err := ubuntuIPLookup( context.Background(), http.DefaultClient, log.Log, model.HTTPHeaderUserAgent, - netxlite.NewStdlibResolver(model.DiscardLogger), + netx.NewStdlibResolver(model.DiscardLogger), ) if err != nil { t.Fatal(err) diff --git a/internal/enginenetx/httpsdialer_test.go b/internal/enginenetx/httpsdialer_test.go index e6010a0a7b..e44ec96a54 100644 --- a/internal/enginenetx/httpsdialer_test.go +++ b/internal/enginenetx/httpsdialer_test.go @@ -493,7 +493,8 @@ func TestHTTPSDialerHostNetworkQA(t *testing.T) { // The resolver we're creating here reproduces the test case described by // https://github.com/ooni/probe-cli/pull/1295#issuecomment-1731243994 - resolver := netxlite.MaybeWrapWithBogonResolver(true, netxlite.NewStdlibResolver(log.Log)) + netx := &netxlite.Netx{} + resolver := netxlite.MaybeWrapWithBogonResolver(true, netx.NewStdlibResolver(log.Log)) httpsDialer := newHTTPSDialer( log.Log, diff --git a/internal/enginenetx/network.go b/internal/enginenetx/network.go index 9d3b222586..fce1d53c7c 100644 --- a/internal/enginenetx/network.go +++ b/internal/enginenetx/network.go @@ -90,7 +90,8 @@ func NewNetwork( // Create a dialer ONLY used for dialing unencrypted TCP connections. The common use // case of this Network is to dial encrypted connections. For this reason, here it is // reasonably fine to use the legacy sequential dialer implemented in netxlite. - dialer := netxlite.NewDialerWithResolver(logger, resolver) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithResolver(logger, resolver) // Create manager for keeping track of statistics const trimInterval = 30 * time.Second @@ -135,12 +136,12 @@ func NewNetwork( // Make sure we count the bytes sent and received as part of the session txp = bytecounter.WrapHTTPTransport(txp, counter) - netx := &Network{ + network := &Network{ reso: resolver, stats: stats, txp: txp, } - return netx + return network } // newHTTPSDialerPolicy contains the logic to select the [HTTPSDialerPolicy] to use. diff --git a/internal/enginenetx/network_internal_test.go b/internal/enginenetx/network_internal_test.go index cc05931079..5b3e7bda8b 100644 --- a/internal/enginenetx/network_internal_test.go +++ b/internal/enginenetx/network_internal_test.go @@ -187,7 +187,7 @@ func TestNetworkUnit(t *testing.T) { tc.kvStore(), log.Log, nil, // proxy URL - netxlite.NewStdlibResolver(log.Log), + (&netxlite.Netx{}).NewStdlibResolver(log.Log), ) defer netx.Close() diff --git a/internal/enginenetx/network_test.go b/internal/enginenetx/network_test.go index 855c6f515c..e7617f9f01 100644 --- a/internal/enginenetx/network_test.go +++ b/internal/enginenetx/network_test.go @@ -25,12 +25,13 @@ func TestNetworkQA(t *testing.T) { defer env.Close() env.Do(func() { + netx := &netxlite.Netx{} txp := enginenetx.NewNetwork( bytecounter.New(), &kvstore.Memory{}, log.Log, nil, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) client := txp.NewHTTPClient() resp, err := client.Get("https://www.example.com/") @@ -62,6 +63,7 @@ func TestNetworkQA(t *testing.T) { defer proxy.Close() env.Do(func() { + netx := &netxlite.Netx{} txp := enginenetx.NewNetwork( bytecounter.New(), &kvstore.Memory{}, @@ -71,7 +73,7 @@ func TestNetworkQA(t *testing.T) { Host: net.JoinHostPort(env.ClientStack.IPAddress(), "9050"), Path: "/", }, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) client := txp.NewHTTPClient() @@ -131,6 +133,7 @@ func TestNetworkQA(t *testing.T) { defer proxy.Close() env.Do(func() { + netx := &netxlite.Netx{} txp := enginenetx.NewNetwork( bytecounter.New(), &kvstore.Memory{}, @@ -140,7 +143,7 @@ func TestNetworkQA(t *testing.T) { Host: net.JoinHostPort(env.ClientStack.IPAddress(), "8080"), Path: "/", }, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) client := txp.NewHTTPClient() @@ -202,6 +205,7 @@ func TestNetworkQA(t *testing.T) { defer proxy.Close() env.Do(func() { + netx := &netxlite.Netx{} txp := enginenetx.NewNetwork( bytecounter.New(), &kvstore.Memory{}, @@ -211,7 +215,7 @@ func TestNetworkQA(t *testing.T) { Host: net.JoinHostPort(env.ClientStack.IPAddress(), "4443"), Path: "/", }, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) client := txp.NewHTTPClient() @@ -257,12 +261,13 @@ func TestNetworkQA(t *testing.T) { }) t.Run("NewHTTPClient returns a client with a cookie jar", func(t *testing.T) { + netx := &netxlite.Netx{} txp := enginenetx.NewNetwork( bytecounter.New(), &kvstore.Memory{}, log.Log, nil, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) client := txp.NewHTTPClient() if client.Jar == nil { diff --git a/internal/enginenetx/statsmanager_test.go b/internal/enginenetx/statsmanager_test.go index 1b8b2c4d40..a94f99d385 100644 --- a/internal/enginenetx/statsmanager_test.go +++ b/internal/enginenetx/statsmanager_test.go @@ -228,7 +228,7 @@ func TestNetworkCollectsStats(t *testing.T) { qa.Do(func() { byteCounter := bytecounter.New() - resolver := netxlite.NewStdlibResolver(log.Log) + resolver := (&netxlite.Netx{}).NewStdlibResolver(log.Log) netx := NewNetwork(byteCounter, kvStore, log.Log, nil, resolver) defer netx.Close() diff --git a/internal/engineresolver/factory.go b/internal/engineresolver/factory.go index 3744100582..5654314037 100644 --- a/internal/engineresolver/factory.go +++ b/internal/engineresolver/factory.go @@ -57,8 +57,9 @@ func newChildResolver( case "http", "https": // http is here for testing reso = newChildResolverHTTPS(logger, URL, http3Enabled, counter, proxyURL) case "system": + netx := &netxlite.Netx{} reso = bytecounter.MaybeWrapSystemResolver( - netxlite.NewStdlibResolver(logger), + netx.NewStdlibResolver(logger), counter, // handles correctly the case where counter is nil ) default: @@ -78,10 +79,11 @@ func newChildResolverHTTPS( proxyURL *url.URL, ) model.Resolver { var txp model.HTTPTransport + netx := &netxlite.Netx{} switch http3Enabled { case false: dialer := netxlite.NewDialerWithStdlibResolver(logger) - thx := netxlite.NewTLSHandshakerStdlib(logger) + thx := netx.NewTLSHandshakerStdlib(logger) tlsDialer := netxlite.NewTLSDialer(dialer, thx) txp = netxlite.NewHTTPTransportWithOptions( logger, dialer, tlsDialer, @@ -89,7 +91,7 @@ func newChildResolverHTTPS( netxlite.HTTPTransportOptionProxyURL(proxyURL), // nil here disables using the proxy ) case true: - txp = netxlite.NewHTTP3TransportStdlib(logger) + txp = netx.NewHTTP3TransportStdlib(logger) } txp = bytecounter.MaybeWrapHTTPTransport(txp, counter) dnstxp := netxlite.NewDNSOverHTTPSTransportWithHTTPTransport(txp, URL) diff --git a/internal/experiment/ndt7/dial.go b/internal/experiment/ndt7/dial.go index eeb0253249..578facdd01 100644 --- a/internal/experiment/ndt7/dial.go +++ b/internal/experiment/ndt7/dial.go @@ -30,8 +30,9 @@ func newDialManager(ndt7URL string, logger model.Logger, userAgent string) dialM } func (mgr dialManager) dialWithTestName(ctx context.Context, testName string) (*websocket.Conn, error) { - reso := netxlite.NewStdlibResolver(mgr.logger) - dlr := netxlite.NewDialerWithResolver(mgr.logger, reso) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(mgr.logger) + dlr := netx.NewDialerWithResolver(mgr.logger, reso) dlr = bytecounter.WrapWithContextAwareDialer(dlr) // Implements shaping if the user builds using `-tags shaping` // See https://github.com/ooni/probe/issues/2112 diff --git a/internal/experiment/simplequicping/simplequicping.go b/internal/experiment/simplequicping/simplequicping.go index cf6a507d23..4869d5ec45 100644 --- a/internal/experiment/simplequicping/simplequicping.go +++ b/internal/experiment/simplequicping/simplequicping.go @@ -172,7 +172,8 @@ func (m *Measurer) quicHandshake(ctx context.Context, index int64, alpn := strings.Split(m.config.alpn(), " ") trace := measurexlite.NewTrace(index, zeroTime) ol := logx.NewOperationLogger(logger, "SimpleQUICPing #%d %s %s %v", index, address, sni, alpn) - listener := netxlite.NewUDPListener() + netx := &netxlite.Netx{} + listener := netx.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/experiment/webconnectivitylte/dnsresolvers.go b/internal/experiment/webconnectivitylte/dnsresolvers.go index 2a5d32ebcf..8fe6572251 100644 --- a/internal/experiment/webconnectivitylte/dnsresolvers.go +++ b/internal/experiment/webconnectivitylte/dnsresolvers.go @@ -249,7 +249,8 @@ func (t *DNSResolvers) lookupHostUDP(parentCtx context.Context, udpAddress strin ) // runs the lookup - dialer := netxlite.NewDialerWithoutResolver(t.Logger) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(t.Logger) reso := trace.NewParallelUDPResolver(t.Logger, dialer, udpAddress) addrs, err := reso.LookupHost(lookupCtx, t.Domain) diff --git a/internal/experiment/webconnectivitylte/dnswhoami.go b/internal/experiment/webconnectivitylte/dnswhoami.go index 1dc1b770d2..882fb29c73 100644 --- a/internal/experiment/webconnectivitylte/dnswhoami.go +++ b/internal/experiment/webconnectivitylte/dnswhoami.go @@ -33,7 +33,8 @@ func (svc *DNSWhoamiService) SystemV4(ctx context.Context) ([]DNSWhoamiInfoEntry if len(svc.systemv4) <= 0 { ctx, cancel := context.WithTimeout(ctx, 4*time.Second) defer cancel() - reso := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(model.DiscardLogger) addrs, err := reso.LookupHost(ctx, "whoami.v4.powerdns.org") if err != nil || len(addrs) < 1 { return nil, false @@ -52,8 +53,9 @@ func (svc *DNSWhoamiService) UDPv4(ctx context.Context, address string) ([]DNSWh if len(svc.udpv4[address]) <= 0 { ctx, cancel := context.WithTimeout(ctx, 4*time.Second) defer cancel() + netx := &netxlite.Netx{} dialer := netxlite.NewDialerWithStdlibResolver(model.DiscardLogger) - reso := netxlite.NewParallelUDPResolver(model.DiscardLogger, dialer, address) + reso := netx.NewParallelUDPResolver(model.DiscardLogger, dialer, address) // TODO(bassosimone): this should actually only send an A query. Sending an AAAA // query is _way_ unnecessary since we know that only A is going to work. addrs, err := reso.LookupHost(ctx, "whoami.v4.powerdns.org") diff --git a/internal/experiment/webconnectivityqa/control_test.go b/internal/experiment/webconnectivityqa/control_test.go index b6bbec240d..7087b16a06 100644 --- a/internal/experiment/webconnectivityqa/control_test.go +++ b/internal/experiment/webconnectivityqa/control_test.go @@ -18,8 +18,9 @@ func TestControlFailureWithSuccessfulHTTPWebsite(t *testing.T) { tc.Configure(env) env.Do(func() { + netx := &netxlite.Netx{} tcpDialer := netxlite.NewDialerWithStdlibResolver(log.Log) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialer(tcpDialer, tlsHandshaker) for _, sni := range []string{"0.th.ooni.org", "1.th.ooni.org", "2.th.ooni.org", "3.th.ooni.org", "d33d1gs9kpq1c5.cloudfront.net"} { conn, err := tlsDialer.DialTLSContext(context.Background(), "tcp", net.JoinHostPort(sni, "443")) @@ -41,8 +42,9 @@ func TestControlFailureWithSuccessfulHTTPSWebsite(t *testing.T) { tc.Configure(env) env.Do(func() { + netx := &netxlite.Netx{} tcpDialer := netxlite.NewDialerWithStdlibResolver(log.Log) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialer(tcpDialer, tlsHandshaker) for _, sni := range []string{"0.th.ooni.org", "1.th.ooni.org", "2.th.ooni.org", "3.th.ooni.org", "d33d1gs9kpq1c5.cloudfront.net"} { conn, err := tlsDialer.DialTLSContext(context.Background(), "tcp", net.JoinHostPort(sni, "443")) diff --git a/internal/experiment/webconnectivityqa/dnsblocking_test.go b/internal/experiment/webconnectivityqa/dnsblocking_test.go index 431f5f3a7d..13bb234238 100644 --- a/internal/experiment/webconnectivityqa/dnsblocking_test.go +++ b/internal/experiment/webconnectivityqa/dnsblocking_test.go @@ -19,7 +19,8 @@ func TestDNSBlockingAndroidDNSCacheNoData(t *testing.T) { tc.Configure(env) env.Do(func() { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if !errors.Is(err, netxlite.ErrAndroidDNSCacheNoData) { t.Fatal("unexpected error", err) @@ -38,7 +39,8 @@ func TestDNSBlockingNXDOMAIN(t *testing.T) { tc.Configure(env) env.Do(func() { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err == nil || err.Error() != netxlite.FailureDNSNXDOMAINError { t.Fatal("unexpected error", err) @@ -57,7 +59,8 @@ func TestDNSBlockingBOGON(t *testing.T) { tc.Configure(env) env.Do(func() { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) diff --git a/internal/experiment/webconnectivityqa/dnshijacking_test.go b/internal/experiment/webconnectivityqa/dnshijacking_test.go index f477408d48..10d21e7b17 100644 --- a/internal/experiment/webconnectivityqa/dnshijacking_test.go +++ b/internal/experiment/webconnectivityqa/dnshijacking_test.go @@ -27,7 +27,8 @@ func TestDNSHijackingTestCases(t *testing.T) { expect := []string{netemx.ISPProxyAddress} t.Run("with stdlib resolver", func(t *testing.T) { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) @@ -38,8 +39,9 @@ func TestDNSHijackingTestCases(t *testing.T) { }) t.Run("with UDP resolver", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) diff --git a/internal/experiment/webconnectivityqa/httpblocking_test.go b/internal/experiment/webconnectivityqa/httpblocking_test.go index 3bcd36a494..6ae79a2671 100644 --- a/internal/experiment/webconnectivityqa/httpblocking_test.go +++ b/internal/experiment/webconnectivityqa/httpblocking_test.go @@ -18,8 +18,9 @@ func TestHTTPBlockingConnectionReset(t *testing.T) { tc.Configure(env) env.Do(func() { + netx := &netxlite.Netx{} dialer := netxlite.NewDialerWithStdlibResolver(log.Log) - tlsDialer := netxlite.NewTLSDialer(dialer, netxlite.NewTLSHandshakerStdlib(log.Log)) + tlsDialer := netxlite.NewTLSDialer(dialer, netx.NewTLSHandshakerStdlib(log.Log)) txp := netxlite.NewHTTPTransportWithOptions(log.Log, dialer, tlsDialer) client := &http.Client{Transport: txp} resp, err := client.Get("http://www.example.com/") diff --git a/internal/experiment/webconnectivityqa/httpdiff_test.go b/internal/experiment/webconnectivityqa/httpdiff_test.go index dcc0af78b6..a696767019 100644 --- a/internal/experiment/webconnectivityqa/httpdiff_test.go +++ b/internal/experiment/webconnectivityqa/httpdiff_test.go @@ -80,7 +80,8 @@ func TestHTTPDiffWithInconsistentDNS(t *testing.T) { expect := []string{netemx.ISPProxyAddress} t.Run("with stdlib resolver", func(t *testing.T) { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) @@ -91,8 +92,9 @@ func TestHTTPDiffWithInconsistentDNS(t *testing.T) { }) t.Run("with UDP resolver", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) diff --git a/internal/experiment/webconnectivityqa/redirect_test.go b/internal/experiment/webconnectivityqa/redirect_test.go index fbf73881bb..acdb74686f 100644 --- a/internal/experiment/webconnectivityqa/redirect_test.go +++ b/internal/experiment/webconnectivityqa/redirect_test.go @@ -32,7 +32,8 @@ func TestRedirectWithConsistentDNSAndThenConnectionRefused(t *testing.T) { for _, port := range ports { t.Run(fmt.Sprintf("for port %s", port), func(t *testing.T) { - dialer := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(log.Log) endpoint := net.JoinHostPort(netemx.AddressWwwExampleCom, port) conn, err := dialer.DialContext(context.Background(), "tcp", endpoint) if err == nil || err.Error() != netxlite.FailureConnectionRefused { @@ -97,7 +98,8 @@ func TestRedirectWithConsistentDNSAndThenNXDOMAIN(t *testing.T) { env.Do(func() { t.Run("with stdlib resolver", func(t *testing.T) { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err == nil || err.Error() != netxlite.FailureDNSNXDOMAINError { t.Fatal("unexpected error", err) @@ -108,8 +110,9 @@ func TestRedirectWithConsistentDNSAndThenNXDOMAIN(t *testing.T) { }) t.Run("with UDP resolver", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err == nil || err.Error() != netxlite.FailureDNSNXDOMAINError { t.Fatal("unexpected error", err) diff --git a/internal/experiment/webconnectivityqa/tcpblocking_test.go b/internal/experiment/webconnectivityqa/tcpblocking_test.go index 5e71802b28..4e973f553d 100644 --- a/internal/experiment/webconnectivityqa/tcpblocking_test.go +++ b/internal/experiment/webconnectivityqa/tcpblocking_test.go @@ -18,7 +18,8 @@ func TestTCPBlockingConnectTimeout(t *testing.T) { tc.Configure(env) env.Do(func() { - dialer := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(log.Log) endpoint := net.JoinHostPort(netemx.AddressWwwExampleCom, "443") conn, err := dialer.DialContext(context.Background(), "tcp", endpoint) if err == nil || err.Error() != netxlite.FailureGenericTimeoutError { @@ -38,7 +39,8 @@ func TestTCPBlockingConnectionRefusedWithInconsistentDNS(t *testing.T) { tc.Configure(env) env.Do(func() { - dialer := netxlite.NewDialerWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) conn, err := dialer.DialContext(context.Background(), "tcp", "www.example.org:443") if err == nil || err.Error() != netxlite.FailureConnectionRefused { t.Fatal("unexpected error", err) diff --git a/internal/experiment/webconnectivityqa/tlsblocking_test.go b/internal/experiment/webconnectivityqa/tlsblocking_test.go index 9676a6df2c..6d984093ff 100644 --- a/internal/experiment/webconnectivityqa/tlsblocking_test.go +++ b/internal/experiment/webconnectivityqa/tlsblocking_test.go @@ -72,7 +72,8 @@ func TestBlockingTLSConnectionResetWithInconsistentDNS(t *testing.T) { expect := []string{netemx.ISPProxyAddress} t.Run("with stdlib resolver", func(t *testing.T) { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) @@ -83,8 +84,9 @@ func TestBlockingTLSConnectionResetWithInconsistentDNS(t *testing.T) { }) t.Run("with UDP resolver", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, d, "8.8.8.8:53") addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { t.Fatal(err) diff --git a/internal/legacy/measurex/dialer.go b/internal/legacy/measurex/dialer.go index d0fc2de28f..d4f1308214 100644 --- a/internal/legacy/measurex/dialer.go +++ b/internal/legacy/measurex/dialer.go @@ -33,14 +33,16 @@ func WrapDialer(begin time.Time, db WritableDB, dialer model.Dialer) model.Diale // NewDialerWithSystemResolver creates a func (mx *Measurer) NewDialerWithSystemResolver(db WritableDB, logger model.Logger) model.Dialer { r := mx.NewResolverSystem(db, logger) - return mx.WrapDialer(db, netxlite.NewDialerWithResolver(logger, r)) + netx := &netxlite.Netx{} + return mx.WrapDialer(db, netx.NewDialerWithResolver(logger, r)) } // NewDialerWithoutResolver is a convenience factory for creating // a dialer that saves measurements into the DB and that is not attached // to any resolver (hence only works when passed IP addresses). func (mx *Measurer) NewDialerWithoutResolver(db WritableDB, logger model.Logger) model.Dialer { - return mx.WrapDialer(db, netxlite.NewDialerWithoutResolver(logger)) + netx := &netxlite.Netx{} + return mx.WrapDialer(db, netx.NewDialerWithoutResolver(logger)) } type dialerDB struct { diff --git a/internal/legacy/measurex/measurer.go b/internal/legacy/measurex/measurer.go index 23f648d856..8f371c5afb 100644 --- a/internal/legacy/measurex/measurer.go +++ b/internal/legacy/measurex/measurer.go @@ -97,6 +97,7 @@ type Measurer struct { // NewMeasurerWithDefaultSettings creates a new Measurer // instance using the most default settings. func NewMeasurerWithDefaultSettings() *Measurer { + netx := &netxlite.Netx{} return &Measurer{ Begin: time.Now(), DNSLookupTimeout: 0, @@ -115,7 +116,7 @@ func NewMeasurerWithDefaultSettings() *Measurer { }}, TCPconnectTimeout: 0, TLSHandshakeTimeout: 0, - TLSHandshaker: netxlite.NewTLSHandshakerStdlib(log.Log), + TLSHandshaker: netx.NewTLSHandshakerStdlib(log.Log), } } diff --git a/internal/legacy/measurex/quic.go b/internal/legacy/measurex/quic.go index 7fdcae0a17..6dc5384ee3 100644 --- a/internal/legacy/measurex/quic.go +++ b/internal/legacy/measurex/quic.go @@ -109,12 +109,13 @@ 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 + netx := &netxlite.Netx{} listener := &udpListenerDB{ - UDPListener: netxlite.NewUDPListener(), + UDPListener: netx.NewUDPListener(), begin: qh.begin, db: qh.db, } - dialer := netxlite.NewQUICDialerWithoutResolver(listener, qh.logger) + dialer := netx.NewQUICDialerWithoutResolver(listener, qh.logger) defer dialer.CloseIdleConnections() sess, err := dialer.DialContext(ctx, address, tlsConfig, quicConfig) if err == nil { diff --git a/internal/legacy/measurex/resolver.go b/internal/legacy/measurex/resolver.go index d546980516..86c5dd10dd 100644 --- a/internal/legacy/measurex/resolver.go +++ b/internal/legacy/measurex/resolver.go @@ -29,7 +29,8 @@ func WrapResolver(begin time.Time, db WritableDB, r model.Resolver) model.Resolv // NewResolverSystem creates a system resolver and then wraps // it using the WrapResolver function. func (mx *Measurer) NewResolverSystem(db WritableDB, logger model.Logger) model.Resolver { - return mx.WrapResolver(db, netxlite.NewStdlibResolver(logger)) + netx := &netxlite.Netx{} + return mx.WrapResolver(db, netx.NewStdlibResolver(logger)) } // NewResolverUDP is a convenience factory for creating a Resolver diff --git a/internal/legacy/measurex/resolver_test.go b/internal/legacy/measurex/resolver_test.go index e067e01e33..e047b28b8f 100644 --- a/internal/legacy/measurex/resolver_test.go +++ b/internal/legacy/measurex/resolver_test.go @@ -12,7 +12,8 @@ func TestResolverModifiesStdlibResolverName(t *testing.T) { // See https://github.com/ooni/spec/pull/257 for more information. t.Run("for LookupHost", func(t *testing.T) { - child := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + child := netx.NewStdlibResolver(model.DiscardLogger) mx := NewMeasurerWithDefaultSettings() dbout := &MeasurementDB{} txp := mx.WrapResolver(dbout, child) @@ -34,7 +35,8 @@ func TestResolverModifiesStdlibResolverName(t *testing.T) { }) t.Run("for LookupHTTPS", func(t *testing.T) { - child := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + child := netx.NewStdlibResolver(model.DiscardLogger) mx := NewMeasurerWithDefaultSettings() dbout := &MeasurementDB{} txp := mx.WrapResolver(dbout, child) diff --git a/internal/legacy/measurex/tls.go b/internal/legacy/measurex/tls.go index b5fe894497..1ef85cd19c 100644 --- a/internal/legacy/measurex/tls.go +++ b/internal/legacy/measurex/tls.go @@ -26,7 +26,8 @@ func (mx *Measurer) WrapTLSHandshaker(db WritableDB, thx model.TLSHandshaker) mo // NewTLSHandshakerStdlib creates a new TLS handshaker that // saves results into the DB and uses the stdlib for TLS. func (mx *Measurer) NewTLSHandshakerStdlib(db WritableDB, logger model.Logger) model.TLSHandshaker { - return mx.WrapTLSHandshaker(db, netxlite.NewTLSHandshakerStdlib(logger)) + netx := &netxlite.Netx{} + return mx.WrapTLSHandshaker(db, netx.NewTLSHandshakerStdlib(logger)) } type tlsHandshakerDB struct { diff --git a/internal/legacy/measurex/tracing.go b/internal/legacy/measurex/tracing.go index 12741b9262..714f12a533 100644 --- a/internal/legacy/measurex/tracing.go +++ b/internal/legacy/measurex/tracing.go @@ -53,10 +53,11 @@ func NewTracingHTTPTransport(logger model.Logger, begin time.Time, db WritableDB // eventually become the measurement func NewTracingHTTPTransportWithDefaultSettings( begin time.Time, logger model.Logger, db WritableDB) *HTTPTransportDB { + netx := &netxlite.Netx{} return NewTracingHTTPTransport(logger, begin, db, - netxlite.NewStdlibResolver(logger), - netxlite.NewDialerWithoutResolver(logger), - netxlite.NewTLSHandshakerStdlib(logger), + netx.NewStdlibResolver(logger), + netx.NewDialerWithoutResolver(logger), + netx.NewTLSHandshakerStdlib(logger), DefaultHTTPMaxBodySnapshotSize) } diff --git a/internal/legacy/netx/dialer.go b/internal/legacy/netx/dialer.go index 29dd31d342..7c2a6ac705 100644 --- a/internal/legacy/netx/dialer.go +++ b/internal/legacy/netx/dialer.go @@ -17,7 +17,8 @@ func NewDialer(config Config) model.Dialer { config.FullResolver = NewResolver(config) } logger := model.ValidLoggerOrDefault(config.Logger) - d := netxlite.NewDialerWithResolver( + netx := &netxlite.Netx{} + d := netx.NewDialerWithResolver( logger, config.FullResolver, config.Saver.NewConnectObserver(), config.ReadWriteSaver.NewReadWriteObserver(), ) diff --git a/internal/legacy/netx/quic.go b/internal/legacy/netx/quic.go index 15ad905e66..091bdc7240 100644 --- a/internal/legacy/netx/quic.go +++ b/internal/legacy/netx/quic.go @@ -16,7 +16,8 @@ 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.WrapUDPListener(netxlite.NewUDPListener()) + netx := &netxlite.Netx{} + ql := config.ReadWriteSaver.WrapUDPListener(netx.NewUDPListener()) logger := model.ValidLoggerOrDefault(config.Logger) - return netxlite.NewQUICDialerWithResolver(ql, logger, config.FullResolver, config.Saver) + return netx.NewQUICDialerWithResolver(ql, logger, config.FullResolver, config.Saver) } diff --git a/internal/legacy/netx/tls.go b/internal/legacy/netx/tls.go index 71328b6ad6..0fc0e95035 100644 --- a/internal/legacy/netx/tls.go +++ b/internal/legacy/netx/tls.go @@ -14,8 +14,9 @@ func NewTLSDialer(config Config) model.TLSDialer { if config.Dialer == nil { config.Dialer = NewDialer(config) } + netx := &netxlite.Netx{} logger := model.ValidLoggerOrDefault(config.Logger) - thx := netxlite.NewTLSHandshakerStdlib(logger) + thx := netx.NewTLSHandshakerStdlib(logger) thx = config.Saver.WrapTLSHandshaker(thx) // WAI even when config.Saver is nil tlsConfig := netxlite.ClonedTLSConfigOrNewEmptyConfig(config.TLSConfig) return netxlite.NewTLSDialerWithConfig(config.Dialer, thx, tlsConfig) diff --git a/internal/legacy/tracex/http_test.go b/internal/legacy/tracex/http_test.go index fed0e6ce77..52a582563e 100644 --- a/internal/legacy/tracex/http_test.go +++ b/internal/legacy/tracex/http_test.go @@ -81,8 +81,9 @@ func TestHTTPTransportSaver(t *testing.T) { measureHTTP := func(t *testing.T, URL *url.URL) (*http.Response, *Saver, error) { saver := &Saver{} + netx := &netxlite.Netx{} txp := &HTTPTransportSaver{ - HTTPTransport: netxlite.NewHTTPTransportStdlib(model.DiscardLogger), + HTTPTransport: netx.NewHTTPTransportStdlib(model.DiscardLogger), Saver: saver, } req, err := http.NewRequest("GET", URL.String(), nil) diff --git a/internal/legacy/tracex/resolver_test.go b/internal/legacy/tracex/resolver_test.go index 5a5b280a3b..d2f34227e9 100644 --- a/internal/legacy/tracex/resolver_test.go +++ b/internal/legacy/tracex/resolver_test.go @@ -116,7 +116,8 @@ func TestResolverSaver(t *testing.T) { t.Run("with stdlib resolver there's correct .Network remapping", func(t *testing.T) { saver := &Saver{} - reso := saver.WrapResolver(netxlite.NewStdlibResolver(model.DiscardLogger)) + netx := &netxlite.Netx{} + reso := saver.WrapResolver(netx.NewStdlibResolver(model.DiscardLogger)) ctx, cancel := context.WithCancel(context.Background()) cancel() // immediately fail the operation _, _ = reso.LookupHost(ctx, "www.google.com") @@ -149,7 +150,8 @@ func TestResolverSaver(t *testing.T) { }) t.Run("when using the stdlib resolver", func(t *testing.T) { - child := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + child := netx.NewStdlibResolver(model.DiscardLogger) switch network := child.Network(); network { case netxlite.StdlibResolverGetaddrinfo, netxlite.StdlibResolverGolangNetResolver: diff --git a/internal/measurexlite/dialer.go b/internal/measurexlite/dialer.go index 8284ec2558..18b37c2c33 100644 --- a/internal/measurexlite/dialer.go +++ b/internal/measurexlite/dialer.go @@ -16,7 +16,7 @@ import ( "github.com/ooni/probe-cli/v3/internal/netxlite" ) -// NewDialerWithoutResolver is equivalent to netxlite.NewDialerWithoutResolver +// NewDialerWithoutResolver is equivalent to [netxlite.Netx.NewDialerWithoutResolver] // except that it returns a model.Dialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the [model.MeasuringNetwork] diff --git a/internal/measurexlite/doc.go b/internal/measurexlite/doc.go index 8a5e717727..69c109385a 100644 --- a/internal/measurexlite/doc.go +++ b/internal/measurexlite/doc.go @@ -16,7 +16,7 @@ // // The [*Trace] features methods that mirror existing [netxlite] methods but implement support for // collecting network events using the [*Trace]. For example, [*Trace.NewStdlibResolver] is like -// [netxlite.NewStdlibResolver] but the DNS lookups performed with the resolved returned by +// [netxlite.Netx.NewStdlibResolver] but the DNS lookups performed with the resolved returned by // [*Trace.NewStdlibResolver] generate events that you can collect using the [*Trace]. // // As mentioned above, internally, the [*Trace] uses buffered channels on which the underlying diff --git a/internal/measurexlite/quic.go b/internal/measurexlite/quic.go index 6df2149c57..7b089de159 100644 --- a/internal/measurexlite/quic.go +++ b/internal/measurexlite/quic.go @@ -14,7 +14,7 @@ import ( "github.com/quic-go/quic-go" ) -// NewQUICDialerWithoutResolver is equivalent to netxlite.NewQUICDialerWithoutResolver +// NewQUICDialerWithoutResolver is equivalent to netxlite.Netx.NewQUICDialerWithoutResolver // except that it returns a model.QUICDialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the [model.MeasuringNetwork] diff --git a/internal/measurexlite/quic_test.go b/internal/measurexlite/quic_test.go index e0d1262574..eede303e63 100644 --- a/internal/measurexlite/quic_test.go +++ b/internal/measurexlite/quic_test.go @@ -284,7 +284,8 @@ func TestOnQUICHandshakeDoneExtractsTheConnectionState(t *testing.T) { trace := NewTrace(0, time.Now()) // create a QUIC dialer - udpListener := netxlite.NewUDPListener() + netx := &netxlite.Netx{} + udpListener := netx.NewUDPListener() quicDialer := trace.NewQUICDialerWithoutResolver(udpListener, model.DiscardLogger) // dial with the endpoint we use for testing diff --git a/internal/measurexlite/tls.go b/internal/measurexlite/tls.go index 636bdae3aa..aa92d059a0 100644 --- a/internal/measurexlite/tls.go +++ b/internal/measurexlite/tls.go @@ -16,7 +16,7 @@ import ( "github.com/ooni/probe-cli/v3/internal/netxlite" ) -// NewTLSHandshakerStdlib is equivalent to netxlite.NewTLSHandshakerStdlib +// NewTLSHandshakerStdlib is equivalent to netxlite.Netx.NewTLSHandshakerStdlib // except that it returns a model.TLSHandshaker that uses this trace. func (tx *Trace) NewTLSHandshakerStdlib(dl model.DebugLogger) model.TLSHandshaker { return &tlsHandshakerTrace{ diff --git a/internal/measurexlite/tls_test.go b/internal/measurexlite/tls_test.go index 4b3e22aa3e..01f5fbb79d 100644 --- a/internal/measurexlite/tls_test.go +++ b/internal/measurexlite/tls_test.go @@ -236,7 +236,8 @@ func TestNewTLSHandshakerStdlib(t *testing.T) { ca := netem.MustNewCA() cert := ca.MustNewTLSCertificate("dns.google") server := testingx.MustNewTLSServer(testingx.TLSHandlerHandshakeAndWriteText(cert, testingx.HTTPBlockpage451)) - dialer := netxlite.NewDialerWithoutResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) ctx := context.Background() conn, err := dialer.DialContext(ctx, "tcp", server.Endpoint()) if err != nil { diff --git a/internal/measurexlite/trace_test.go b/internal/measurexlite/trace_test.go index 686d6540d7..7266b3e59c 100644 --- a/internal/measurexlite/trace_test.go +++ b/internal/measurexlite/trace_test.go @@ -190,7 +190,8 @@ func TestTrace(t *testing.T) { t.Run("NewParallelUDPResolver works as intended", func(t *testing.T) { tx := NewTrace(0, time.Now()) - dialer := netxlite.NewDialerWithoutResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) resolver := tx.NewParallelUDPResolver(model.DiscardLogger, dialer, "1.1.1.1:53") ctx, cancel := context.WithCancel(context.Background()) cancel() diff --git a/internal/measurexlite/utls.go b/internal/measurexlite/utls.go index d00016006b..9250b884c3 100644 --- a/internal/measurexlite/utls.go +++ b/internal/measurexlite/utls.go @@ -9,7 +9,7 @@ import ( utls "gitlab.com/yawning/utls.git" ) -// NewTLSHandshakerUTLS is equivalent to netxlite.NewTLSHandshakerUTLS +// NewTLSHandshakerUTLS is equivalent to netxlite.Netx.NewTLSHandshakerUTLS // except that it returns a model.TLSHandshaker that uses this trace. func (tx *Trace) NewTLSHandshakerUTLS(dl model.DebugLogger, id *utls.ClientHelloID) model.TLSHandshaker { return &tlsHandshakerTrace{ diff --git a/internal/netemx/android_test.go b/internal/netemx/android_test.go index 1bab281463..5d8d555373 100644 --- a/internal/netemx/android_test.go +++ b/internal/netemx/android_test.go @@ -18,7 +18,8 @@ func TestEmulateAndroidGetaddrinfo(t *testing.T) { defer env.EmulateAndroidGetaddrinfo(false) env.Do(func() { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) addrs, err := reso.LookupHost(context.Background(), "www.nonexistent.xyz") if !errors.Is(err, netxlite.ErrAndroidDNSCacheNoData) { t.Fatal("unexpected error") diff --git a/internal/netemx/badssl_test.go b/internal/netemx/badssl_test.go index 1dcfdd910a..a07d5b8469 100644 --- a/internal/netemx/badssl_test.go +++ b/internal/netemx/badssl_test.go @@ -43,9 +43,10 @@ func TestBadSSL(t *testing.T) { t.Run(fmt.Sprintf("for %s expect %s", tc.serverName, tc.expectErr), func(t *testing.T) { tlsConfig := &tls.Config{ServerName: tc.serverName} + netx := &netxlite.Netx{} tlsDialer := netxlite.NewTLSDialerWithConfig( - netxlite.NewDialerWithoutResolver(log.Log), - netxlite.NewTLSHandshakerStdlib(log.Log), + netx.NewDialerWithoutResolver(log.Log), + netx.NewTLSHandshakerStdlib(log.Log), tlsConfig, ) diff --git a/internal/netemx/dnsoverudp_test.go b/internal/netemx/dnsoverudp_test.go index 6d0499cef8..58a87404ec 100644 --- a/internal/netemx/dnsoverudp_test.go +++ b/internal/netemx/dnsoverudp_test.go @@ -19,8 +19,9 @@ func TestDNSOverUDPServerFactory(t *testing.T) { env.AddRecordToAllResolvers("www.example.com", "", AddressWwwExampleCom) env.Do(func() { - reso := netxlite.NewParallelUDPResolver( - log.Log, netxlite.NewDialerWithoutResolver(log.Log), + netx := &netxlite.Netx{} + reso := netx.NewParallelUDPResolver( + log.Log, netx.NewDialerWithoutResolver(log.Log), net.JoinHostPort(AddressDNSGoogle8844, "53")) addrs, err := reso.LookupHost(context.Background(), "www.example.com") if err != nil { diff --git a/internal/netemx/example_test.go b/internal/netemx/example_test.go index 6d70a44440..4fc8662367 100644 --- a/internal/netemx/example_test.go +++ b/internal/netemx/example_test.go @@ -80,7 +80,8 @@ func Example_dpiRule() { // run netxlite code inside the netemx environment env.Do(func() { // create a system resolver instance - reso := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(model.DiscardLogger) // create the HTTP client // TODO(https://github.com/ooni/probe/issues/2534): the NewHTTPClientWithResolver func has QUIRKS but we don't care. @@ -131,23 +132,25 @@ func Example_resolverConfig() { // run netxlite code inside the netemx environment env.Do(func() { + netx := &netxlite.Netx{} + // use a system resolver instance { - reso := netxlite.NewStdlibResolver(log.Log) + reso := netx.NewStdlibResolver(log.Log) ispResults = runtimex.Try1(reso.LookupHost(context.Background(), "example.com")) } // use 8.8.4.4 { - dialer := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, "8.8.4.4:53") + dialer := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, dialer, "8.8.4.4:53") googleResults = runtimex.Try1(reso.LookupHost(context.Background(), "example.com")) } // use 9.9.9.9 { - dialer := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, "9.9.9.9:53") + dialer := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, dialer, "9.9.9.9:53") quad9Results = runtimex.Try1(reso.LookupHost(context.Background(), "example.com")) } }) @@ -178,11 +181,14 @@ func Example_customNetStackHandler() { // run netxlite code inside the netemx environment env.Do(func() { + // use the default netxlite.Netx. + netx := &netxlite.Netx{} + // create a system resolver instance - reso := netxlite.NewStdlibResolver(log.Log) + reso := netx.NewStdlibResolver(log.Log) // create a dialer - dialer := netxlite.NewDialerWithResolver(log.Log, reso) + dialer := netx.NewDialerWithResolver(log.Log, reso) // attempt to establish a TCP connection conn, err := dialer.DialContext(context.Background(), "tcp", "e1.whatsapp.net:5222") @@ -224,10 +230,12 @@ func Example_dohWithInternetScenario() { env.Do(func() { for _, domain := range []string{"mozilla.cloudflare-dns.com", "dns.google", "dns.quad9.net"} { + netx := &netxlite.Netx{} + // DNS-over-UDP { - dialer := netxlite.NewDialerWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, net.JoinHostPort(domain, "53")) + dialer := netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) + reso := netx.NewParallelUDPResolver(log.Log, dialer, net.JoinHostPort(domain, "53")) defer reso.CloseIdleConnections() addrs, err := reso.LookupHost(context.Background(), "www.example.com") @@ -240,8 +248,9 @@ func Example_dohWithInternetScenario() { // DNS-over-HTTPS { + netx := &netxlite.Netx{} URL := &url.URL{Scheme: "https", Host: domain, Path: "/dns-query"} - reso := netxlite.NewParallelDNSOverHTTPSResolver(log.Log, URL.String()) + reso := netx.NewParallelDNSOverHTTPSResolver(log.Log, URL.String()) defer reso.CloseIdleConnections() addrs, err := reso.LookupHost(context.Background(), "www.example.com") @@ -279,8 +288,9 @@ func Example_dnsOverUDPWithInternetScenario() { } for _, endpoint := range resolvers { - dialer := netxlite.NewDialerWithoutResolver(log.Log) - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, endpoint) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(log.Log) + reso := netx.NewParallelUDPResolver(log.Log, dialer, endpoint) defer reso.CloseIdleConnections() addrs, err := reso.LookupHost(context.Background(), "www.example.com") @@ -307,7 +317,8 @@ func Example_getaddrinfoWithInternetScenario() { defer env.Close() env.Do(func() { - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) defer reso.CloseIdleConnections() addrs, err := reso.LookupHost(context.Background(), "www.example.com") @@ -548,7 +559,8 @@ func Example_exampleURLShortener() { env.Do(func() { // TODO(https://github.com/ooni/probe/issues/2534): NewHTTPTransportStdlib has QUIRKS but we // don't actually care about those QUIRKS in this context - client := netxlite.NewHTTPTransportStdlib(log.Log) + netx := &netxlite.Netx{} + client := netx.NewHTTPTransportStdlib(log.Log) req, err := http.NewRequest("GET", "https://bit.ly/21645", nil) if err != nil { diff --git a/internal/netemx/http3_test.go b/internal/netemx/http3_test.go index 7de7a51bd3..bc11c54cb0 100644 --- a/internal/netemx/http3_test.go +++ b/internal/netemx/http3_test.go @@ -27,7 +27,8 @@ func TestHTTP3ServerFactory(t *testing.T) { env.AddRecordToAllResolvers("www.example.com", "", AddressWwwExampleCom) env.Do(func() { - client := netxlite.NewHTTP3ClientWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) + netx := &netxlite.Netx{} + client := netxlite.NewHTTP3ClientWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) req := runtimex.Try1(http.NewRequest("GET", "https://www.example.com/", nil)) resp, err := client.Do(req) if err != nil { diff --git a/internal/netemx/qaenv_test.go b/internal/netemx/qaenv_test.go index 9d264b20d4..18138a2a33 100644 --- a/internal/netemx/qaenv_test.go +++ b/internal/netemx/qaenv_test.go @@ -39,7 +39,8 @@ func TestQAEnv(t *testing.T) { env.Do(func() { // create stdlib resolver, which will use the underlying client stack // GetaddrinfoLookupANY method for the DNS lookup - reso := netxlite.NewStdlibResolver(model.DiscardLogger) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(model.DiscardLogger) // lookup the hostname ctx := context.Background() @@ -165,7 +166,8 @@ func TestQAEnv(t *testing.T) { env.Do(func() { // create an HTTP3 client - txp := netxlite.NewHTTP3TransportStdlib(model.DiscardLogger) + netx := &netxlite.Netx{} + txp := netx.NewHTTP3TransportStdlib(model.DiscardLogger) client := &http.Client{Transport: txp} // create the request; see above remarks for the HTTPS case diff --git a/internal/netxlite/dialer.go b/internal/netxlite/dialer.go index f85ed64763..70d4922432 100644 --- a/internal/netxlite/dialer.go +++ b/internal/netxlite/dialer.go @@ -15,11 +15,12 @@ import ( ) // NewDialerWithStdlibResolver is equivalent to creating a system resolver -// using NewStdlibResolver and then a dialer using NewDialerWithResolver where -// the resolver argument is the previously created resolver. +// using NewStdlibResolver and then a dialer using [Netx.NewDialerWithResolver] +// with the default [Netx] where the resolver argument is the previously created resolver. func NewDialerWithStdlibResolver(dl model.DebugLogger) model.Dialer { - reso := NewStdlibResolver(dl) - return NewDialerWithResolver(dl, reso) + netx := &Netx{} + reso := netx.NewStdlibResolver(dl) + return netx.NewDialerWithResolver(dl, reso) } // NewDialerWithResolver creates a [Dialer] with error wrapping. @@ -36,17 +37,10 @@ func (netx *Netx) NewDialerWithResolver(dl model.DebugLogger, r model.Resolver, return WrapDialer(dl, r, &dialerSystem{provider: netx.MaybeCustomUnderlyingNetwork()}, w...) } -// NewDialerWithResolver is equivalent to creating an empty [*Netx] -// and calling its NewDialerWithResolver method. -func NewDialerWithResolver(dl model.DebugLogger, r model.Resolver, w ...model.DialerWrapper) model.Dialer { - netx := &Netx{Underlying: nil} - return netx.NewDialerWithResolver(dl, r, w...) -} - // WrapDialer wraps an existing Dialer to add extra functionality // such as separting DNS lookup and connecting, error wrapping, logging, etc. // -// When possible use NewDialerWithResolver or NewDialerWithoutResolver +// When possible use [Netx.NewDialerWithResolver] or NewDialerWithoutResolver // instead of using this rather low-level function. // // # Arguments @@ -156,13 +150,6 @@ func (netx *Netx) NewDialerWithoutResolver(dl model.DebugLogger, w ...model.Dial return netx.NewDialerWithResolver(dl, &NullResolver{}, w...) } -// NewDialerWithoutResolver is equivalent to creating an empty [*Netx] -// and calling its NewDialerWithoutResolver method. -func NewDialerWithoutResolver(dl model.DebugLogger, w ...model.DialerWrapper) model.Dialer { - netx := &Netx{Underlying: nil} - return netx.NewDialerWithoutResolver(dl, w...) -} - // dialerSystem is a model.Dialer that uses the stdlib's net.Dialer // to construct the new SimpleDialer used for dialing. This dialer has // a fixed timeout for each connect operation equal to 15 seconds. diff --git a/internal/netxlite/dialer_test.go b/internal/netxlite/dialer_test.go index 05332210dc..866887cdfe 100644 --- a/internal/netxlite/dialer_test.go +++ b/internal/netxlite/dialer_test.go @@ -61,7 +61,8 @@ func TestNewDialer(t *testing.T) { nil, // explicitly test for this documented case &dialerWrapperSecond{}, } - d := NewDialerWithoutResolver(log.Log, modifiers...) + netx := &Netx{} + d := netx.NewDialerWithoutResolver(log.Log, modifiers...) logger := d.(*dialerLogger) if logger.DebugLogger != log.Log { t.Fatal("invalid logger") diff --git a/internal/netxlite/dnsoverhttps_test.go b/internal/netxlite/dnsoverhttps_test.go index dd3d06fa87..71406450d5 100644 --- a/internal/netxlite/dnsoverhttps_test.go +++ b/internal/netxlite/dnsoverhttps_test.go @@ -32,7 +32,8 @@ func TestNewDNSOverHTTPSTransportWithHTTPTransport(t *testing.T) { const URL = "https://1.1.1.1/dns-query" // TODO(https://github.com/ooni/probe/issues/2534): NewHTTPTransportStdlib has QUIRKS but we // don't actually care about those QUIRKS in this context - httpTxp := NewHTTPTransportStdlib(model.DiscardLogger) + netx := &Netx{} + httpTxp := netx.NewHTTPTransportStdlib(model.DiscardLogger) txp := NewDNSOverHTTPSTransportWithHTTPTransport(httpTxp, URL) ew := txp.(*dnsTransportErrWrapper) https := ew.DNSTransport.(*DNSOverHTTPSTransport) diff --git a/internal/netxlite/dnsoverudp_test.go b/internal/netxlite/dnsoverudp_test.go index d9da739569..d317bba770 100644 --- a/internal/netxlite/dnsoverudp_test.go +++ b/internal/netxlite/dnsoverudp_test.go @@ -261,7 +261,8 @@ func TestDNSOverUDPTransport(t *testing.T) { dnsRtx := testingx.NewDNSRoundTripperWithDNSConfig(dnsConfig) listener := testingx.MustNewDNSOverUDPListener(udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsRtx) defer listener.Close() - dialer := NewDialerWithoutResolver(model.DiscardLogger) + netx := &Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) txp := NewUnwrappedDNSOverUDPTransport(dialer, listener.LocalAddr().String()) encoder := &DNSEncoderMiekg{} query := encoder.Encode("dns.google.", dns.TypeA, false) @@ -294,7 +295,8 @@ func TestDNSOverUDPTransport(t *testing.T) { listener := testingx.MustNewDNSSimulateGWFListener( udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsConfigBogus, dnsConfigGood, testingx.DNSNumBogusResponses(1)) - dialer := NewDialerWithoutResolver(model.DiscardLogger) + netx := &Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) expectedAddress := listener.LocalAddr().String() txp := NewUnwrappedDNSOverUDPTransport(dialer, expectedAddress) txp.lateResponses = make(chan any, 1) // with buffer to avoid deadlocks @@ -329,7 +331,8 @@ func TestDNSOverUDPTransport(t *testing.T) { udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsConfigBogus, dnsConfigGood, testingx.DNSNumBogusResponses(1)) defer listener.Close() - dialer := NewDialerWithoutResolver(model.DiscardLogger) + netx := &Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) expectedAddress := listener.LocalAddr().String() txp := NewUnwrappedDNSOverUDPTransport(dialer, expectedAddress) encoder := &DNSEncoderMiekg{} @@ -420,7 +423,8 @@ func TestDNSOverUDPTransport(t *testing.T) { udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsConfigBogus, netem.NewDNSConfig(), testingx.DNSNumBogusResponses(1)) defer listener.Close() - dialer := NewDialerWithoutResolver(model.DiscardLogger) + netx := &Netx{} + dialer := netx.NewDialerWithoutResolver(model.DiscardLogger) expectedAddress := listener.LocalAddr().String() txp := NewUnwrappedDNSOverUDPTransport(dialer, expectedAddress) encoder := &DNSEncoderMiekg{} @@ -506,7 +510,8 @@ func TestDNSOverUDPTransport(t *testing.T) { t.Run("other functions okay", func(t *testing.T) { const address = "9.9.9.9:53" - txp := NewUnwrappedDNSOverUDPTransport(NewDialerWithoutResolver(log.Log), address) + netx := &Netx{} + txp := NewUnwrappedDNSOverUDPTransport(netx.NewDialerWithoutResolver(log.Log), address) if txp.RequiresPadding() != false { t.Fatal("invalid RequiresPadding") } diff --git a/internal/netxlite/http3.go b/internal/netxlite/http3.go index f31ffcdc6d..21caa3a91b 100644 --- a/internal/netxlite/http3.go +++ b/internal/netxlite/http3.go @@ -71,17 +71,11 @@ func (netx *Netx) NewHTTP3TransportStdlib(logger model.DebugLogger) model.HTTPTr return NewHTTP3Transport(logger, qd, nil) } -// NewHTTP3TransportStdlib is equivalent to creating an empty [*Netx] -// and calling its NewHTTP3TransportStdlib method. -func NewHTTP3TransportStdlib(logger model.DebugLogger) model.HTTPTransport { - netx := &Netx{Underlying: nil} - return netx.NewHTTP3TransportStdlib(logger) -} - // 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(NewUDPListener(), logger, reso) + netx := &Netx{} + qd := netx.NewQUICDialerWithResolver(netx.NewUDPListener(), logger, reso) return NewHTTP3Transport(logger, qd, nil) } diff --git a/internal/netxlite/http3_test.go b/internal/netxlite/http3_test.go index 7d7dbee4dc..b0583e5865 100644 --- a/internal/netxlite/http3_test.go +++ b/internal/netxlite/http3_test.go @@ -125,7 +125,8 @@ func TestNewHTTP3Transport(t *testing.T) { func TestNewHTTP3TransportStdlib(t *testing.T) { t.Run("creates the correct type chain", func(t *testing.T) { - txp := NewHTTP3TransportStdlib(model.DiscardLogger) + netx := &Netx{} + txp := netx.NewHTTP3TransportStdlib(model.DiscardLogger) verifyTypeChainForHTTP3(t, txp, model.DiscardLogger, nil, nil, nil) }) } diff --git a/internal/netxlite/httpquirks.go b/internal/netxlite/httpquirks.go index d4c26945e0..b18b9786e1 100644 --- a/internal/netxlite/httpquirks.go +++ b/internal/netxlite/httpquirks.go @@ -20,8 +20,9 @@ import ( // // This function behavior is QUIRKY as documented in [NewHTTPTransport]. func NewHTTPTransportWithResolver(logger model.DebugLogger, reso model.Resolver) model.HTTPTransport { - dialer := NewDialerWithResolver(logger, reso) - thx := NewTLSHandshakerStdlib(logger) + netx := &Netx{} + dialer := netx.NewDialerWithResolver(logger, reso) + thx := netx.NewTLSHandshakerStdlib(logger) tlsDialer := NewTLSDialer(dialer, thx) return NewHTTPTransport(logger, dialer, tlsDialer) } @@ -108,21 +109,13 @@ func (netx *Netx) NewHTTPTransportStdlib(logger model.DebugLogger) model.HTTPTra return NewHTTPTransport(logger, dialer, tlsDialer) } -// NewHTTPTransportStdlib is equivalent to creating an empty [*Netx] -// and calling its NewHTTPTransportStdlib method. -// -// This function behavior is QUIRKY as documented in [NewHTTPTransport]. -func NewHTTPTransportStdlib(logger model.DebugLogger) model.HTTPTransport { - netx := &Netx{Underlying: nil} - return netx.NewHTTPTransportStdlib(logger) -} - // NewHTTPClientStdlib creates a new HTTPClient that uses the // standard library for TLS and DNS resolutions. // // This function behavior is QUIRKY as documented in [NewHTTPTransport]. func NewHTTPClientStdlib(logger model.DebugLogger) model.HTTPClient { - txp := NewHTTPTransportStdlib(logger) + netx := &Netx{} + txp := netx.NewHTTPTransportStdlib(logger) return NewHTTPClient(txp) } diff --git a/internal/netxlite/httpquirks_test.go b/internal/netxlite/httpquirks_test.go index 3043293e4e..0056197e55 100644 --- a/internal/netxlite/httpquirks_test.go +++ b/internal/netxlite/httpquirks_test.go @@ -38,6 +38,7 @@ func TestNewHTTPTransport(t *testing.T) { t.Run("works as intended with failing dialer", func(t *testing.T) { called := &atomic.Int64{} expected := errors.New("mocked error") + netx := &Netx{} d := &dialerResolverWithTracing{ Dialer: &mocks.Dialer{ MockDialContext: func(ctx context.Context, @@ -48,9 +49,9 @@ func TestNewHTTPTransport(t *testing.T) { called.Add(1) }, }, - Resolver: NewStdlibResolver(log.Log), + Resolver: netx.NewStdlibResolver(log.Log), } - td := NewTLSDialer(d, NewTLSHandshakerStdlib(log.Log)) + td := NewTLSDialer(d, netx.NewTLSHandshakerStdlib(log.Log)) txp := NewHTTPTransport(log.Log, d, td) client := &http.Client{Transport: txp} resp, err := client.Get("https://8.8.4.4/robots.txt") @@ -104,7 +105,8 @@ func TestNewHTTPTransport(t *testing.T) { } func TestNewHTTPTransportStdlib(t *testing.T) { - txp := NewHTTPTransportStdlib(log.Log) + netx := &Netx{} + txp := netx.NewHTTPTransportStdlib(log.Log) ctx, cancel := context.WithCancel(context.Background()) cancel() // immediately! req, err := http.NewRequestWithContext(ctx, "GET", "http://x.org", nil) diff --git a/internal/netxlite/integration_test.go b/internal/netxlite/integration_test.go index cdf8378351..81a5036259 100644 --- a/internal/netxlite/integration_test.go +++ b/internal/netxlite/integration_test.go @@ -43,7 +43,8 @@ func TestMeasureWithSystemResolver(t *testing.T) { // t.Run("on success", func(t *testing.T) { - r := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + r := netx.NewStdlibResolver(log.Log) defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "dns.google.com") @@ -56,7 +57,8 @@ func TestMeasureWithSystemResolver(t *testing.T) { }) t.Run("for nxdomain", func(t *testing.T) { - r := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + r := netx.NewStdlibResolver(log.Log) defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "www.ooni.nonexistent") @@ -69,7 +71,8 @@ func TestMeasureWithSystemResolver(t *testing.T) { }) t.Run("for timeout", func(t *testing.T) { - r := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + r := netx.NewStdlibResolver(log.Log) defer r.CloseIdleConnections() const timeout = time.Nanosecond ctx, cancel := context.WithTimeout(context.Background(), timeout) @@ -108,8 +111,9 @@ func TestMeasureWithUDPResolver(t *testing.T) { // t.Run("on success", func(t *testing.T) { - dlr := netxlite.NewDialerWithoutResolver(log.Log) - r := netxlite.NewParallelUDPResolver(log.Log, dlr, "8.8.4.4:53") + netx := &netxlite.Netx{} + dlr := netx.NewDialerWithoutResolver(log.Log) + r := netx.NewParallelUDPResolver(log.Log, dlr, "8.8.4.4:53") defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "dns.google.com") @@ -129,8 +133,9 @@ func TestMeasureWithUDPResolver(t *testing.T) { dnsRtx := testingx.NewDNSRoundTripperNXDOMAIN() listener := testingx.MustNewDNSOverUDPListener(udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsRtx) defer listener.Close() - dlr := netxlite.NewDialerWithoutResolver(log.Log) - r := netxlite.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) + netx := &netxlite.Netx{} + dlr := netx.NewDialerWithoutResolver(log.Log) + r := netx.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "ooni.org") @@ -150,8 +155,9 @@ func TestMeasureWithUDPResolver(t *testing.T) { dnsRtx := testingx.NewDNSRoundTripperRefused() listener := testingx.MustNewDNSOverUDPListener(udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsRtx) defer listener.Close() - dlr := netxlite.NewDialerWithoutResolver(log.Log) - r := netxlite.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) + netx := &netxlite.Netx{} + dlr := netx.NewDialerWithoutResolver(log.Log) + r := netx.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "ooni.org") @@ -171,8 +177,9 @@ func TestMeasureWithUDPResolver(t *testing.T) { dnsRtx := testingx.NewDNSRoundTripperSimulateTimeout(time.Millisecond, errors.New("mocked error")) listener := testingx.MustNewDNSOverUDPListener(udpAddr, &testingx.DNSOverUDPListenerStdlib{}, dnsRtx) defer listener.Close() - dlr := netxlite.NewDialerWithoutResolver(log.Log) - r := netxlite.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) + netx := &netxlite.Netx{} + dlr := netx.NewDialerWithoutResolver(log.Log) + r := netx.NewParallelUDPResolver(log.Log, dlr, listener.LocalAddr().String()) defer r.CloseIdleConnections() ctx := context.Background() addrs, err := r.LookupHost(ctx, "ooni.org") @@ -201,7 +208,8 @@ func TestMeasureWithDialer(t *testing.T) { // t.Run("on success", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) defer d.CloseIdleConnections() ctx := context.Background() conn, err := d.DialContext(ctx, "tcp", "8.8.4.4:443") @@ -215,7 +223,8 @@ func TestMeasureWithDialer(t *testing.T) { }) t.Run("on connection refused", func(t *testing.T) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) defer d.CloseIdleConnections() ctx := context.Background() // Here we assume that no-one is listening on 127.0.0.1:1 @@ -242,7 +251,8 @@ func TestMeasureWithDialer(t *testing.T) { // the kernel races with the timeout we've configured. For this // reason, I have set a smaller context timeout (see below). // - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) defer d.CloseIdleConnections() const timeout = 5 * time.Second ctx, cancel := context.WithTimeout(context.Background(), timeout) @@ -276,7 +286,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { // dial := func(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } @@ -395,7 +406,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { t.Run("for stdlib handshaker", func(t *testing.T) { t.Run("on success", func(t *testing.T) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) err := successFlow(th) if err != nil { t.Fatal(err) @@ -403,7 +415,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on connection reset", func(t *testing.T) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) err := connectionResetFlow(th) if err != nil { t.Fatal(err) @@ -411,7 +424,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on timeout", func(t *testing.T) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) err := timeoutFlow(th) if err != nil { t.Fatal(err) @@ -419,7 +433,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on TLS unrecognized name alert", func(t *testing.T) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) err := tlsUnrecognizedNameFlow(th) if err != nil { t.Fatal(err) @@ -429,7 +444,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { t.Run("for utls handshaker", func(t *testing.T) { t.Run("on success", func(t *testing.T) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) err := successFlow(th) if err != nil { t.Fatal(err) @@ -437,7 +453,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on connection reset", func(t *testing.T) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) err := connectionResetFlow(th) if err != nil { t.Fatal(err) @@ -445,7 +462,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on timeout", func(t *testing.T) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) err := timeoutFlow(th) if err != nil { t.Fatal(err) @@ -453,7 +471,8 @@ func TestMeasureWithTLSHandshaker(t *testing.T) { }) t.Run("on TLS unrecognized name alert", func(t *testing.T) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) err := tlsUnrecognizedNameFlow(th) if err != nil { t.Fatal(err) @@ -479,8 +498,9 @@ func TestMeasureWithQUICDialer(t *testing.T) { // t.Run("on success", func(t *testing.T) { - ql := netxlite.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) defer d.CloseIdleConnections() ctx := context.Background() // See https://github.com/ooni/probe/issues/2413 to understand @@ -502,8 +522,9 @@ func TestMeasureWithQUICDialer(t *testing.T) { }) t.Run("on timeout", func(t *testing.T) { - ql := netxlite.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) defer d.CloseIdleConnections() ctx := context.Background() // See https://github.com/ooni/probe/issues/2413 to understand @@ -531,8 +552,9 @@ func TestHTTPTransport(t *testing.T) { } t.Run("works as intended", func(t *testing.T) { - d := netxlite.NewDialerWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) - td := netxlite.NewTLSDialer(d, netxlite.NewTLSHandshakerStdlib(log.Log)) + netx := &netxlite.Netx{} + d := netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) + td := netxlite.NewTLSDialer(d, netx.NewTLSHandshakerStdlib(log.Log)) txp := netxlite.NewHTTPTransport(log.Log, d, td) client := &http.Client{Transport: txp} resp, err := client.Get("https://www.google.com/robots.txt") @@ -557,7 +579,8 @@ func TestHTTPTransport(t *testing.T) { defer srvr.Close() // TODO(https://github.com/ooni/probe/issues/2534): NewHTTPTransportStdlib has QUIRKS but we // don't actually care about those QUIRKS in this context - txp := netxlite.NewHTTPTransportStdlib(model.DiscardLogger) + netx := &netxlite.Netx{} + txp := netx.NewHTTPTransportStdlib(model.DiscardLogger) req, err := http.NewRequest("GET", srvr.URL, nil) if err != nil { t.Fatal(err) @@ -581,10 +604,11 @@ func TestHTTP3Transport(t *testing.T) { } t.Run("works as intended", func(t *testing.T) { - d := netxlite.NewQUICDialerWithResolver( - netxlite.NewUDPListener(), + netx := &netxlite.Netx{} + d := netx.NewQUICDialerWithResolver( + netx.NewUDPListener(), log.Log, - netxlite.NewStdlibResolver(log.Log), + netx.NewStdlibResolver(log.Log), ) txp := netxlite.NewHTTP3Transport(log.Log, d, &tls.Config{}) client := &http.Client{Transport: txp} diff --git a/internal/netxlite/quic.go b/internal/netxlite/quic.go index 41eda13fb5..8f2334b64b 100644 --- a/internal/netxlite/quic.go +++ b/internal/netxlite/quic.go @@ -18,7 +18,7 @@ import ( // NewQUICDialerWithResolver creates a QUICDialer with error wrapping. // -// Unlike the dialer returned by NewDialerWithResolver, this dialer MAY attempt +// Unlike the dialer returned by [Netx.NewDialerWithResolver], this dialer MAY attempt // happy eyeballs, perform parallel dial attempts, and return an error // that aggregates all the errors that occurred. // @@ -34,14 +34,6 @@ func (netx *Netx) NewQUICDialerWithResolver(listener model.UDPListener, logger m return wrapQUICDialer(logger, resolver, baseDialer, wrappers...) } -// NewQUICDialerWithResolver is equivalent to creating an empty [*Netx] -// and calling its NewQUICDialerWithResolver method. -func NewQUICDialerWithResolver(listener model.UDPListener, logger model.DebugLogger, - resolver model.Resolver, wrappers ...model.QUICDialerWrapper) (outDialer model.QUICDialer) { - netx := &Netx{Underlying: nil} - return netx.NewQUICDialerWithResolver(listener, logger, resolver, wrappers...) -} - // wrapQUICDialer is similar to NewQUICDialerWithResolver except that it takes as // input an already constructed [model.QUICDialer] instead of creating one. func wrapQUICDialer(logger model.DebugLogger, resolver model.Resolver, @@ -76,14 +68,6 @@ func (netx *Netx) NewQUICDialerWithoutResolver(listener model.UDPListener, return netx.NewQUICDialerWithResolver(listener, logger, &NullResolver{}, wrappers...) } -// NewQUICDialerWithoutResolver is equivalent to creating an empty [*Netx] -// and calling its NewQUICDialerWithoutResolver method. -func NewQUICDialerWithoutResolver(listener model.UDPListener, - logger model.DebugLogger, wrappers ...model.QUICDialerWrapper) model.QUICDialer { - netx := &Netx{Underlying: nil} - return netx.NewQUICDialerWithoutResolver(listener, logger, wrappers...) -} - // quicDialerQUICGo dials using the quic-go/quic-go library. type quicDialerQUICGo struct { // UDPListener is the underlying UDPListener to use. diff --git a/internal/netxlite/quic_test.go b/internal/netxlite/quic_test.go index 5cc60afa34..1a07967ec2 100644 --- a/internal/netxlite/quic_test.go +++ b/internal/netxlite/quic_test.go @@ -42,13 +42,14 @@ func (*quicDialerWrapperSecond) WrapQUICDialer(qd model.QUICDialer) model.QUICDi } func TestNewQUICDialer(t *testing.T) { - ql := NewUDPListener() + netx := &Netx{} + ql := netx.NewUDPListener() extensions := []model.QUICDialerWrapper{ &quicDialerWrapperFirst{}, nil, // explicitly test for this documented case &quicDialerWrapperSecond{}, } - dlr := NewQUICDialerWithoutResolver(ql, log.Log, extensions...) + dlr := netx.NewQUICDialerWithoutResolver(ql, log.Log, extensions...) logger := dlr.(*quicDialerLogger) if logger.Logger != log.Log { t.Fatal("invalid logger") @@ -549,8 +550,9 @@ func TestQUICDialerResolver(t *testing.T) { t.Run("DialContext", func(t *testing.T) { t.Run("with missing port", func(t *testing.T) { tlsConfig := &tls.Config{} + netx := &Netx{} dialer := &quicDialerResolver{ - Resolver: NewStdlibResolver(log.Log), + Resolver: netx.NewStdlibResolver(log.Log), Dialer: &quicDialerQUICGo{}} qconn, err := dialer.DialContext( context.Background(), "www.google.com", @@ -585,9 +587,10 @@ func TestQUICDialerResolver(t *testing.T) { t.Run("with invalid, non-numeric port)", func(t *testing.T) { // This test allows us to check for the case where every attempt // to establish a connection leads to a failure + netx := &Netx{} tlsConf := &tls.Config{} dialer := &quicDialerResolver{ - Resolver: NewStdlibResolver(log.Log), + Resolver: netx.NewStdlibResolver(log.Log), Dialer: &quicDialerQUICGo{ UDPListener: &udpListenerStdlib{}, }} @@ -609,8 +612,9 @@ func TestQUICDialerResolver(t *testing.T) { expected := errors.New("mocked error") var gotTLSConfig *tls.Config tlsConfig := &tls.Config{} + netx := &Netx{} dialer := &quicDialerResolver{ - Resolver: NewStdlibResolver(log.Log), + Resolver: netx.NewStdlibResolver(log.Log), Dialer: &mocks.QUICDialer{ MockDialContext: func(ctx context.Context, address string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { @@ -637,8 +641,9 @@ func TestQUICDialerResolver(t *testing.T) { t.Run("on success", func(t *testing.T) { expectedQConn := &mocks.QUICEarlyConnection{} + netx := &Netx{} dialer := &quicDialerResolver{ - Resolver: NewStdlibResolver(log.Log), + Resolver: netx.NewStdlibResolver(log.Log), Dialer: &mocks.QUICDialer{ MockDialContext: func(ctx context.Context, address string, tlsConfig *tls.Config, quicConfig *quic.Config) (quic.EarlyConnection, error) { diff --git a/internal/netxlite/resolvercore.go b/internal/netxlite/resolvercore.go index 48119288ed..6a46beaa07 100644 --- a/internal/netxlite/resolvercore.go +++ b/internal/netxlite/resolvercore.go @@ -28,13 +28,6 @@ func (netx *Netx) NewStdlibResolver(logger model.DebugLogger) model.Resolver { return WrapResolver(logger, netx.newUnwrappedStdlibResolver()) } -// NewStdlibResolver is equivalent to creating an empty [*Netx] -// and calling its NewStdlibResolver method. -func NewStdlibResolver(logger model.DebugLogger) model.Resolver { - netx := &Netx{Underlying: nil} - return netx.NewStdlibResolver(logger) -} - // NewParallelDNSOverHTTPSResolver implements [model.MeasuringNetwork]. func (netx *Netx) NewParallelDNSOverHTTPSResolver(logger model.DebugLogger, URL string) model.Resolver { client := &http.Client{Transport: netx.NewHTTPTransportStdlib(logger)} @@ -42,13 +35,6 @@ func (netx *Netx) NewParallelDNSOverHTTPSResolver(logger model.DebugLogger, URL return WrapResolver(logger, NewUnwrappedParallelResolver(txp)) } -// NewParallelDNSOverHTTPSResolver is equivalent to creating an empty [*Netx] -// and calling its NewParallelDNSOverHTTPSResolver method. -func NewParallelDNSOverHTTPSResolver(logger model.DebugLogger, URL string) model.Resolver { - netx := &Netx{Underlying: nil} - return netx.NewParallelDNSOverHTTPSResolver(logger, URL) -} - func (netx *Netx) newUnwrappedStdlibResolver() model.Resolver { return &resolverSystem{ t: wrapDNSTransport(netx.newDNSOverGetaddrinfoTransport()), @@ -58,6 +44,8 @@ func (netx *Netx) newUnwrappedStdlibResolver() model.Resolver { // NewUnwrappedStdlibResolver returns a new, unwrapped resolver using the standard // library (i.e., getaddrinfo if possible and &net.Resolver{} otherwise). As the name // implies, this function returns an unwrapped resolver. +// +// Deprecated: do not use this function inside new networking code. func NewUnwrappedStdlibResolver() model.Resolver { netx := &Netx{Underlying: nil} return netx.newUnwrappedStdlibResolver() @@ -66,7 +54,7 @@ func NewUnwrappedStdlibResolver() model.Resolver { // NewSerialUDPResolver creates a new Resolver using DNS-over-UDP // that performs serial A/AAAA lookups during LookupHost. // -// Deprecated: use NewParallelResolverUDP. +// Deprecated: use NewParallelUDPResolver. // // Arguments: // @@ -88,13 +76,6 @@ func (netx *Netx) NewParallelUDPResolver(logger model.DebugLogger, dialer model. )) } -// NewParallelUDPResolver is equivalent to creating an empty [*Netx] -// and calling its NewParallelUDPResolver method. -func NewParallelUDPResolver(logger model.DebugLogger, dialer model.Dialer, address string) model.Resolver { - netx := &Netx{Underlying: nil} - return netx.NewParallelUDPResolver(logger, dialer, address) -} - // WrapResolver creates a new resolver that wraps an // existing resolver to add these properties: // diff --git a/internal/netxlite/resolvercore_test.go b/internal/netxlite/resolvercore_test.go index 57b58fad33..43df93aa58 100644 --- a/internal/netxlite/resolvercore_test.go +++ b/internal/netxlite/resolvercore_test.go @@ -31,12 +31,14 @@ func typeCheckForSystemResolver(t *testing.T, resolver model.Resolver, logger mo } func TestNewResolverSystem(t *testing.T) { - resolver := NewStdlibResolver(model.DiscardLogger) + netx := &Netx{} + resolver := netx.NewStdlibResolver(model.DiscardLogger) typeCheckForSystemResolver(t, resolver, model.DiscardLogger) } func TestNewSerialUDPResolver(t *testing.T) { - d := NewDialerWithoutResolver(log.Log) + netx := &Netx{} + d := netx.NewDialerWithoutResolver(log.Log) resolver := NewSerialUDPResolver(log.Log, d, "1.1.1.1:53") idnaReso := resolver.(*resolverIDNA) logger := idnaReso.Resolver.(*resolverLogger) @@ -54,8 +56,9 @@ func TestNewSerialUDPResolver(t *testing.T) { } func TestNewParallelUDPResolver(t *testing.T) { - d := NewDialerWithoutResolver(log.Log) - resolver := NewParallelUDPResolver(log.Log, d, "1.1.1.1:53") + netx := &Netx{} + d := netx.NewDialerWithoutResolver(log.Log) + resolver := netx.NewParallelUDPResolver(log.Log, d, "1.1.1.1:53") idnaReso := resolver.(*resolverIDNA) logger := idnaReso.Resolver.(*resolverLogger) if logger.Logger != log.Log { @@ -72,7 +75,8 @@ func TestNewParallelUDPResolver(t *testing.T) { } func TestNewParallelDNSOverHTTPSResolver(t *testing.T) { - resolver := NewParallelDNSOverHTTPSResolver(log.Log, "https://1.1.1.1/dns-query") + netx := &Netx{} + resolver := netx.NewParallelDNSOverHTTPSResolver(log.Log, "https://1.1.1.1/dns-query") idnaReso := resolver.(*resolverIDNA) logger := idnaReso.Resolver.(*resolverLogger) if logger.Logger != log.Log { diff --git a/internal/netxlite/tls.go b/internal/netxlite/tls.go index 14df796eca..bd573fd143 100644 --- a/internal/netxlite/tls.go +++ b/internal/netxlite/tls.go @@ -162,13 +162,6 @@ func (netx *Netx) NewTLSHandshakerStdlib(logger model.DebugLogger) model.TLSHand ) } -// NewTLSHandshakerStdlib is equivalent to creating an empty [*Netx] -// and calling its NewTLSHandshakerStdlib method. -func NewTLSHandshakerStdlib(logger model.DebugLogger) model.TLSHandshaker { - netx := &Netx{Underlying: nil} - return netx.NewTLSHandshakerStdlib(logger) -} - // newTLSHandshakerLogger creates a new tlsHandshakerLogger instance. func newTLSHandshakerLogger(th model.TLSHandshaker, logger model.DebugLogger) model.TLSHandshaker { return &tlsHandshakerLogger{ diff --git a/internal/netxlite/tls_test.go b/internal/netxlite/tls_test.go index dcedf7b3ac..7ea23aec08 100644 --- a/internal/netxlite/tls_test.go +++ b/internal/netxlite/tls_test.go @@ -123,7 +123,8 @@ func TestConfigureTLSVersion(t *testing.T) { } func TestNewTLSHandshakerStdlib(t *testing.T) { - th := NewTLSHandshakerStdlib(log.Log) + netx := &Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) logger := th.(*tlsHandshakerLogger) if logger.DebugLogger != log.Log { t.Fatal("invalid logger") @@ -403,7 +404,8 @@ func TestTLSHandshakerConfigurable(t *testing.T) { if err != nil { t.Fatal(err) } - thx := NewTLSHandshakerStdlib(model.DiscardLogger) + netx := &Netx{} + thx := netx.NewTLSHandshakerStdlib(model.DiscardLogger) tlsConfig := &tls.Config{ InsecureSkipVerify: true, ServerName: expectedSNI, @@ -514,7 +516,8 @@ func TestTLSHandshakerConfigurable(t *testing.T) { } }, } - thx := NewTLSHandshakerStdlib(model.DiscardLogger) + netx := &Netx{} + thx := netx.NewTLSHandshakerStdlib(model.DiscardLogger) tlsConfig := &tls.Config{ InsecureSkipVerify: true, ServerName: expectedSNI, diff --git a/internal/netxlite/udp.go b/internal/netxlite/udp.go index 170d2e479f..c3935c9ba9 100644 --- a/internal/netxlite/udp.go +++ b/internal/netxlite/udp.go @@ -12,13 +12,6 @@ func (netx *Netx) NewUDPListener() model.UDPListener { return &udpListenerErrWrapper{&udpListenerStdlib{provider: netx.MaybeCustomUnderlyingNetwork()}} } -// NewUDPListener is equivalent to creating an empty [*Netx] -// and calling its NewUDPListener method. -func NewUDPListener() model.UDPListener { - netx := &Netx{Underlying: nil} - return netx.NewUDPListener() -} - // udpListenerStdlib is a UDPListener using the standard library. type udpListenerStdlib struct { // provider is the OPTIONAL nil-safe [model.UnderlyingNetwork] provider. diff --git a/internal/netxlite/udp_test.go b/internal/netxlite/udp_test.go index 77c9864e68..4691f6559c 100644 --- a/internal/netxlite/udp_test.go +++ b/internal/netxlite/udp_test.go @@ -3,7 +3,8 @@ package netxlite import "testing" func TestNewUDPListener(t *testing.T) { - ql := NewUDPListener() + netx := &Netx{} + ql := netx.NewUDPListener() qew := ql.(*udpListenerErrWrapper) _ = qew.UDPListener.(*udpListenerStdlib) } diff --git a/internal/netxlite/utls.go b/internal/netxlite/utls.go index 5b988dc096..ba5e096c6a 100644 --- a/internal/netxlite/utls.go +++ b/internal/netxlite/utls.go @@ -24,13 +24,6 @@ func (netx *Netx) NewTLSHandshakerUTLS(logger model.DebugLogger, id *utls.Client }, logger) } -// NewTLSHandshakerUTLS is equivalent to creating an empty [*Netx] -// and calling its NewTLSHandshakerUTLS method. -func NewTLSHandshakerUTLS(logger model.DebugLogger, id *utls.ClientHelloID) model.TLSHandshaker { - netx := &Netx{Underlying: nil} - return netx.NewTLSHandshakerUTLS(logger, id) -} - // UTLSConn implements TLSConn and uses a utls UConn as its underlying connection type UTLSConn struct { // We include the real UConn diff --git a/internal/netxlite/utls_test.go b/internal/netxlite/utls_test.go index f771262d89..59c1fd90cb 100644 --- a/internal/netxlite/utls_test.go +++ b/internal/netxlite/utls_test.go @@ -15,7 +15,8 @@ import ( ) func TestNewTLSHandshakerUTLS(t *testing.T) { - th := NewTLSHandshakerUTLS(log.Log, &utls.HelloChrome_83) + netx := &Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloChrome_83) logger := th.(*tlsHandshakerLogger) if logger.DebugLogger != log.Log { t.Fatal("invalid logger") diff --git a/internal/oohelperd/handler.go b/internal/oohelperd/handler.go index 989e3a4daa..c14b0a5e8f 100644 --- a/internal/oohelperd/handler.go +++ b/internal/oohelperd/handler.go @@ -70,6 +70,7 @@ var _ http.Handler = &Handler{} // NewHandler constructs the [handler]. func NewHandler() *Handler { + netx := &netxlite.Netx{} return &Handler{ BaseLogger: log.Log, CountRequests: &atomic.Int64{}, @@ -94,17 +95,17 @@ func NewHandler() *Handler { }, NewDialer: func(logger model.Logger) model.Dialer { - return netxlite.NewDialerWithoutResolver(logger) + return netx.NewDialerWithoutResolver(logger) }, NewQUICDialer: func(logger model.Logger) model.QUICDialer { - return netxlite.NewQUICDialerWithoutResolver( - netxlite.NewUDPListener(), + return netx.NewQUICDialerWithoutResolver( + netx.NewUDPListener(), logger, ) }, NewResolver: newResolver, NewTLSHandshaker: func(logger model.Logger) model.TLSHandshaker { - return netxlite.NewTLSHandshakerStdlib(logger) + return netx.NewTLSHandshakerStdlib(logger) }, } } @@ -205,7 +206,8 @@ func newResolver(logger model.Logger) model.Resolver { // Implementation note: pin to a specific resolver so we don't depend upon the // default resolver configured by the box. Also, use an encrypted transport thus // we're less vulnerable to any policy implemented by the box's provider. - resolver := netxlite.NewParallelDNSOverHTTPSResolver(logger, "https://dns.google/dns-query") + netx := &netxlite.Netx{} + resolver := netx.NewParallelDNSOverHTTPSResolver(logger, "https://dns.google/dns-query") return resolver } diff --git a/internal/testingproxy/hosthttp.go b/internal/testingproxy/hosthttp.go index bc4de6ec7f..004226a43a 100644 --- a/internal/testingproxy/hosthttp.go +++ b/internal/testingproxy/hosthttp.go @@ -56,7 +56,7 @@ func (tc *hostNetworkTestCaseWithHTTP) Run(t *testing.T) { ExpectAddress: "127.0.0.1", Dialer: netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)), } - tlsDialer := netxlite.NewTLSDialer(dialer, netxlite.NewTLSHandshakerStdlib(log.Log)) + tlsDialer := netxlite.NewTLSDialer(dialer, netx.NewTLSHandshakerStdlib(log.Log)) txp := netxlite.NewHTTPTransportWithOptions(log.Log, dialer, tlsDialer, netxlite.HTTPTransportOptionProxyURL(runtimex.Try1(url.Parse(proxyServer.URL)))) client := &http.Client{Transport: txp} diff --git a/internal/testingproxy/hosthttps.go b/internal/testingproxy/hosthttps.go index 911e3c50a1..7066b2dc50 100644 --- a/internal/testingproxy/hosthttps.go +++ b/internal/testingproxy/hosthttps.go @@ -71,7 +71,7 @@ func (tc *hostNetworkTestCaseWithHTTPWithTLS) Run(t *testing.T) { Dialer: netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)), } tlsDialer := netxlite.NewTLSDialerWithConfig( - dialer, netxlite.NewTLSHandshakerStdlib(log.Log), + dialer, netx.NewTLSHandshakerStdlib(log.Log), tlsConfig, ) txp := netxlite.NewHTTPTransportWithOptions(log.Log, dialer, tlsDialer, diff --git a/internal/testingproxy/sockshost.go b/internal/testingproxy/sockshost.go index 6249b0397c..061a14008d 100644 --- a/internal/testingproxy/sockshost.go +++ b/internal/testingproxy/sockshost.go @@ -56,7 +56,7 @@ func (tc *hostNetworkTestCaseWithSOCKS) Run(t *testing.T) { ExpectAddress: "127.0.0.1", Dialer: netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)), } - tlsDialer := netxlite.NewTLSDialer(dialer, netxlite.NewTLSHandshakerStdlib(log.Log)) + tlsDialer := netxlite.NewTLSDialer(dialer, netx.NewTLSHandshakerStdlib(log.Log)) txp := netxlite.NewHTTPTransportWithOptions(log.Log, dialer, tlsDialer, netxlite.HTTPTransportOptionProxyURL(proxyServer.URL())) client := &http.Client{Transport: txp} diff --git a/internal/testingx/httptestx_test.go b/internal/testingx/httptestx_test.go index 00a6d4d830..57211ce70d 100644 --- a/internal/testingx/httptestx_test.go +++ b/internal/testingx/httptestx_test.go @@ -161,8 +161,9 @@ func TestHTTPTestxWithStdlib(t *testing.T) { // create the HTTP client (we need to do more work than normally because // we MUST correctly set the TLS dialer configuration) - tcpDialer := netxlite.NewDialerWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + tcpDialer := netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialerWithConfig( tcpDialer, tlsHandshaker, &tls.Config{RootCAs: srvr.X509CertPool}) // TODO(https://github.com/ooni/probe/issues/2534): here we're using the QUIRKY netxlite.NewHTTPTransport @@ -440,8 +441,9 @@ func TestHTTPTestxWithNetem(t *testing.T) { // create the HTTP client (we need to do more work than normally because // we MUST correctly set the TLS dialer configuration) - tcpDialer := netxlite.NewDialerWithResolver(log.Log, netxlite.NewStdlibResolver(log.Log)) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + tcpDialer := netx.NewDialerWithResolver(log.Log, netx.NewStdlibResolver(log.Log)) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialerWithConfig( tcpDialer, tlsHandshaker, &tls.Config{RootCAs: srvr.X509CertPool}) // TODO(https://github.com/ooni/probe/issues/2534): here we're using the QUIRKY netxlite.NewHTTPTransport diff --git a/internal/testingx/tlsx_test.go b/internal/testingx/tlsx_test.go index 3df4d3e3e6..045689b3c5 100644 --- a/internal/testingx/tlsx_test.go +++ b/internal/testingx/tlsx_test.go @@ -98,8 +98,9 @@ func TestTLSHandlerWithStdlib(t *testing.T) { } // create a TLS dialer - tcpDialer := netxlite.NewDialerWithoutResolver(log.Log) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + tcpDialer := netx.NewDialerWithoutResolver(log.Log) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialerWithConfig(tcpDialer, tlsHandshaker, tlsConfig) // create a context with a timeout @@ -242,8 +243,9 @@ func TestTLSHandlerWithNetem(t *testing.T) { } // create a TLS dialer - tcpDialer := netxlite.NewDialerWithoutResolver(log.Log) - tlsHandshaker := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + tcpDialer := netx.NewDialerWithoutResolver(log.Log) + tlsHandshaker := netx.NewTLSHandshakerStdlib(log.Log) tlsDialer := netxlite.NewTLSDialerWithConfig(tcpDialer, tlsHandshaker, tlsConfig) // create a context with a timeout diff --git a/internal/tutorial/netxlite/chapter01/README.md b/internal/tutorial/netxlite/chapter01/README.md index 492cebed66..2b796ff2a7 100644 --- a/internal/tutorial/netxlite/chapter01/README.md +++ b/internal/tutorial/netxlite/chapter01/README.md @@ -95,7 +95,8 @@ where we want to perform each operation independently. ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } diff --git a/internal/tutorial/netxlite/chapter01/main.go b/internal/tutorial/netxlite/chapter01/main.go index 1249149dd0..c667c296f2 100644 --- a/internal/tutorial/netxlite/chapter01/main.go +++ b/internal/tutorial/netxlite/chapter01/main.go @@ -96,7 +96,8 @@ func main() { // // ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } diff --git a/internal/tutorial/netxlite/chapter02/README.md b/internal/tutorial/netxlite/chapter02/README.md index 70ea352b21..a0df9b71c5 100644 --- a/internal/tutorial/netxlite/chapter02/README.md +++ b/internal/tutorial/netxlite/chapter02/README.md @@ -102,7 +102,8 @@ The `dialTCP` function is exactly as in the previous chapter. ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } @@ -127,7 +128,8 @@ chapter why this guarantee helps when writing more complex code.) ```Go func handshakeTLS(ctx context.Context, tcpConn net.Conn, config *tls.Config) (model.TLSConn, error) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) return th.Handshake(ctx, tcpConn, config) } diff --git a/internal/tutorial/netxlite/chapter02/main.go b/internal/tutorial/netxlite/chapter02/main.go index b2d9424092..e2edd59f36 100644 --- a/internal/tutorial/netxlite/chapter02/main.go +++ b/internal/tutorial/netxlite/chapter02/main.go @@ -103,7 +103,8 @@ func main() { // ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } @@ -128,7 +129,8 @@ func dialTCP(ctx context.Context, address string) (net.Conn, error) { // ```Go func handshakeTLS(ctx context.Context, tcpConn net.Conn, config *tls.Config) (model.TLSConn, error) { - th := netxlite.NewTLSHandshakerStdlib(log.Log) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerStdlib(log.Log) return th.Handshake(ctx, tcpConn, config) } diff --git a/internal/tutorial/netxlite/chapter03/README.md b/internal/tutorial/netxlite/chapter03/README.md index 482cb6350b..5899eb1c16 100644 --- a/internal/tutorial/netxlite/chapter03/README.md +++ b/internal/tutorial/netxlite/chapter03/README.md @@ -63,7 +63,8 @@ func main() { } func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } @@ -82,7 +83,8 @@ the `tls.Config` (such as the ALPN) may be ignored if they conflict with what the parroted browser would do. ```Go - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) ``` The rest of the program is exactly like the one in the diff --git a/internal/tutorial/netxlite/chapter03/main.go b/internal/tutorial/netxlite/chapter03/main.go index b94f52fd27..6220dd8c1a 100644 --- a/internal/tutorial/netxlite/chapter03/main.go +++ b/internal/tutorial/netxlite/chapter03/main.go @@ -64,7 +64,8 @@ func main() { } func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } @@ -83,7 +84,8 @@ func handshakeTLS(ctx context.Context, tcpConn net.Conn, config *tls.Config) (mo // if they conflict with what the parroted browser would do. // // ```Go - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) // ``` // // The rest of the program is exactly like the one in the diff --git a/internal/tutorial/netxlite/chapter04/README.md b/internal/tutorial/netxlite/chapter04/README.md index 65820b088c..b7fb032165 100644 --- a/internal/tutorial/netxlite/chapter04/README.md +++ b/internal/tutorial/netxlite/chapter04/README.md @@ -91,8 +91,9 @@ in the next two chapters.) ```Go func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { return nil, tls.ConnectionState{}, err diff --git a/internal/tutorial/netxlite/chapter04/main.go b/internal/tutorial/netxlite/chapter04/main.go index d1d649af77..d8ba02829e 100644 --- a/internal/tutorial/netxlite/chapter04/main.go +++ b/internal/tutorial/netxlite/chapter04/main.go @@ -92,8 +92,9 @@ func main() { // ```Go func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { return nil, tls.ConnectionState{}, err diff --git a/internal/tutorial/netxlite/chapter05/README.md b/internal/tutorial/netxlite/chapter05/README.md index c58e14ccae..91cf3fe194 100644 --- a/internal/tutorial/netxlite/chapter05/README.md +++ b/internal/tutorial/netxlite/chapter05/README.md @@ -54,7 +54,8 @@ The returned resolver implements an interface that is very close to the API of the `net.Resolver` struct. ```Go - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) ``` We call `LookupHost` to map the hostname to IP addrs. The returned diff --git a/internal/tutorial/netxlite/chapter05/main.go b/internal/tutorial/netxlite/chapter05/main.go index a0273f074f..3f90342972 100644 --- a/internal/tutorial/netxlite/chapter05/main.go +++ b/internal/tutorial/netxlite/chapter05/main.go @@ -55,7 +55,8 @@ func main() { // close to the API of the `net.Resolver` struct. // // ```Go - reso := netxlite.NewStdlibResolver(log.Log) + netx := &netxlite.Netx{} + reso := netx.NewStdlibResolver(log.Log) // ``` // // We call `LookupHost` to map the hostname to IP addrs. The returned diff --git a/internal/tutorial/netxlite/chapter06/README.md b/internal/tutorial/netxlite/chapter06/README.md index bc69b66b73..541f34ef85 100644 --- a/internal/tutorial/netxlite/chapter06/README.md +++ b/internal/tutorial/netxlite/chapter06/README.md @@ -45,7 +45,8 @@ Here's where we start to diverge. We create a dialer without a resolver, which is going to be used by the UDP resolver. ```Go - dialer := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(log.Log) ``` Then, we create an UDP resolver. The arguments are the same as for @@ -53,7 +54,7 @@ creating a system resolver, except that we also need to specify the UDP endpoint address at which the server is listening. ```Go - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, *serverAddr) + reso := netx.NewParallelUDPResolver(log.Log, dialer, *serverAddr) ``` The API we invoke is the same as in the previous chapter, though, diff --git a/internal/tutorial/netxlite/chapter06/main.go b/internal/tutorial/netxlite/chapter06/main.go index 99a431337c..c14bac3290 100644 --- a/internal/tutorial/netxlite/chapter06/main.go +++ b/internal/tutorial/netxlite/chapter06/main.go @@ -46,7 +46,8 @@ func main() { // which is going to be used by the UDP resolver. // // ```Go - dialer := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + dialer := netx.NewDialerWithoutResolver(log.Log) // ``` // // Then, we create an UDP resolver. The arguments are the same as for @@ -54,7 +55,7 @@ func main() { // UDP endpoint address at which the server is listening. // // ```Go - reso := netxlite.NewParallelUDPResolver(log.Log, dialer, *serverAddr) + reso := netx.NewParallelUDPResolver(log.Log, dialer, *serverAddr) // ``` // // The API we invoke is the same as in the previous chapter, though, diff --git a/internal/tutorial/netxlite/chapter07/README.md b/internal/tutorial/netxlite/chapter07/README.md index 0fd9248353..f9aa91755e 100644 --- a/internal/tutorial/netxlite/chapter07/README.md +++ b/internal/tutorial/netxlite/chapter07/README.md @@ -116,12 +116,14 @@ exactly like what we've seen in chapter03. ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } func handshakeTLS(ctx context.Context, tcpConn net.Conn, config *tls.Config) (model.TLSConn, error) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) return th.Handshake(ctx, tcpConn, config) } diff --git a/internal/tutorial/netxlite/chapter07/main.go b/internal/tutorial/netxlite/chapter07/main.go index 465d12fcb9..22db8e5120 100644 --- a/internal/tutorial/netxlite/chapter07/main.go +++ b/internal/tutorial/netxlite/chapter07/main.go @@ -117,12 +117,14 @@ func main() { // ```Go func dialTCP(ctx context.Context, address string) (net.Conn, error) { - d := netxlite.NewDialerWithoutResolver(log.Log) + netx := &netxlite.Netx{} + d := netx.NewDialerWithoutResolver(log.Log) return d.DialContext(ctx, "tcp", address) } func handshakeTLS(ctx context.Context, tcpConn net.Conn, config *tls.Config) (model.TLSConn, error) { - th := netxlite.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) + netx := &netxlite.Netx{} + th := netx.NewTLSHandshakerUTLS(log.Log, &utls.HelloFirefox_55) return th.Handshake(ctx, tcpConn, config) } diff --git a/internal/tutorial/netxlite/chapter08/README.md b/internal/tutorial/netxlite/chapter08/README.md index 646f12b192..6eee204ab4 100644 --- a/internal/tutorial/netxlite/chapter08/README.md +++ b/internal/tutorial/netxlite/chapter08/README.md @@ -104,8 +104,9 @@ 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.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { return nil, tls.ConnectionState{}, err diff --git a/internal/tutorial/netxlite/chapter08/main.go b/internal/tutorial/netxlite/chapter08/main.go index d7cc0886e8..fab1e930f5 100644 --- a/internal/tutorial/netxlite/chapter08/main.go +++ b/internal/tutorial/netxlite/chapter08/main.go @@ -105,8 +105,9 @@ func main() { func dialQUIC(ctx context.Context, address string, config *tls.Config) (quic.EarlyConnection, tls.ConnectionState, error) { - ql := netxlite.NewUDPListener() - d := netxlite.NewQUICDialerWithoutResolver(ql, log.Log) + netx := &netxlite.Netx{} + ql := netx.NewUDPListener() + d := netx.NewQUICDialerWithoutResolver(ql, log.Log) qconn, err := d.DialContext(ctx, address, config, &quic.Config{}) if err != nil { return nil, tls.ConnectionState{}, err diff --git a/internal/x/dslvm/trace.go b/internal/x/dslvm/trace.go index 8523f2b109..459a2129c7 100644 --- a/internal/x/dslvm/trace.go +++ b/internal/x/dslvm/trace.go @@ -22,7 +22,7 @@ type Trace interface { // Index returns the unique index used by this trace. Index() int64 - // NewDialerWithoutResolver is equivalent to netxlite.NewDialerWithoutResolver + // NewDialerWithoutResolver is equivalent to netxlite.Netx.NewDialerWithoutResolver // except that it returns a model.Dialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the @@ -33,7 +33,7 @@ type Trace interface { NewParallelUDPResolver(logger model.DebugLogger, dialer model.Dialer, address string) model.Resolver // NewQUICDialerWithoutResolver is equivalent to - // netxlite.NewQUICDialerWithoutResolver except that it returns a + // netxlite.Netx.NewQUICDialerWithoutResolver except that it returns a // model.QUICDialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the @@ -41,7 +41,7 @@ type Trace interface { NewQUICDialerWithoutResolver(listener model.UDPListener, dl model.DebugLogger, wrappers ...model.QUICDialerWrapper) model.QUICDialer - // NewTLSHandshakerStdlib is equivalent to netxlite.NewTLSHandshakerStdlib + // NewTLSHandshakerStdlib is equivalent to netxlite.Netx.NewTLSHandshakerStdlib // except that it returns a model.TLSHandshaker that uses this trace. NewTLSHandshakerStdlib(dl model.DebugLogger) model.TLSHandshaker diff --git a/internal/x/dslx/quic_test.go b/internal/x/dslx/quic_test.go index 8272055a94..d2f4fd97ef 100644 --- a/internal/x/dslx/quic_test.go +++ b/internal/x/dslx/quic_test.go @@ -82,12 +82,13 @@ func TestQUICHandshake(t *testing.T) { for name, tt := range tests { t.Run(name, func(t *testing.T) { + netx := &netxlite.Netx{} rt := NewRuntimeMeasurexLite(model.DiscardLogger, time.Now(), RuntimeMeasurexLiteOptionMeasuringNetwork(&mocks.MeasuringNetwork{ MockNewQUICDialerWithoutResolver: func(listener model.UDPListener, logger model.DebugLogger, w ...model.QUICDialerWrapper) model.QUICDialer { return tt.dialer }, MockNewUDPListener: func() model.UDPListener { - return netxlite.NewUDPListener() + return netx.NewUDPListener() }, })) quicHandshake := QUICHandshake(rt, TLSHandshakeOptionServerName(tt.sni)) diff --git a/internal/x/dslx/trace.go b/internal/x/dslx/trace.go index 8cc9f4030f..ce3c1fbc1d 100644 --- a/internal/x/dslx/trace.go +++ b/internal/x/dslx/trace.go @@ -22,7 +22,7 @@ type Trace interface { // Index returns the unique index used by this trace. Index() int64 - // NewDialerWithoutResolver is equivalent to netxlite.NewDialerWithoutResolver + // NewDialerWithoutResolver is equivalent to netxlite.Netx.NewDialerWithoutResolver // except that it returns a model.Dialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the @@ -33,7 +33,7 @@ type Trace interface { NewParallelUDPResolver(logger model.DebugLogger, dialer model.Dialer, address string) model.Resolver // NewQUICDialerWithoutResolver is equivalent to - // netxlite.NewQUICDialerWithoutResolver except that it returns a + // netxlite.Netx.NewQUICDialerWithoutResolver except that it returns a // model.QUICDialer that uses this trace. // // Caveat: the dialer wrappers are there to implement the @@ -41,7 +41,7 @@ type Trace interface { NewQUICDialerWithoutResolver(listener model.UDPListener, dl model.DebugLogger, wrappers ...model.QUICDialerWrapper) model.QUICDialer - // NewTLSHandshakerStdlib is equivalent to netxlite.NewTLSHandshakerStdlib + // NewTLSHandshakerStdlib is equivalent to netxlite.Netx.NewTLSHandshakerStdlib // except that it returns a model.TLSHandshaker that uses this trace. NewTLSHandshakerStdlib(dl model.DebugLogger) model.TLSHandshaker