From da227849f92cb89ecb6178553f0103c62978e157 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Thu, 28 Sep 2023 11:44:31 +0200 Subject: [PATCH 01/11] net: specify network to GetAddrInfoW in port lookup Change-Id: I33a7e7e7b0f224c222f7a3d5fb6e748d45f63df3 --- src/net/lookup_test.go | 9 +++++++++ src/net/lookup_windows.go | 27 ++++++++++++++++++--------- 2 files changed, 27 insertions(+), 9 deletions(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index ab68d75836e454..9720ba2ab44d8f 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1468,3 +1468,12 @@ func TestLookupPortNotFound(t *testing.T) { t.Fatalf("unexpected error: %v", err) } } + +func TestLookupPortDifferentNetwork(t *testing.T) { + // imaps service is only avilable with a tcp network, see: + // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps + _, err := LookupPort("udp", "imaps") + if dnsErr, ok := err.(*DNSError); !ok || !dnsErr.IsNotFound { + t.Fatalf("unexpected error: %v", err) + } +} diff --git a/src/net/lookup_windows.go b/src/net/lookup_windows.go index ce0df7ddd88088..60709416b8dbf4 100644 --- a/src/net/lookup_windows.go +++ b/src/net/lookup_windows.go @@ -200,18 +200,27 @@ func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int // TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this. acquireThread() defer releaseThread() - var stype int32 + + var hints syscall.AddrinfoW + switch network { - case "tcp4", "tcp6": - stype = syscall.SOCK_STREAM - case "udp4", "udp6": - stype = syscall.SOCK_DGRAM + case "tcp", "tcp4", "tcp6": + hints.Socktype = syscall.SOCK_STREAM + hints.Protocol = syscall.IPPROTO_TCP + case "udp", "udp4", "udp6": + hints.Socktype = syscall.SOCK_DGRAM + hints.Protocol = syscall.IPPROTO.UDP + default: + return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} } - hints := syscall.AddrinfoW{ - Family: syscall.AF_UNSPEC, - Socktype: stype, - Protocol: syscall.IPPROTO_IP, + + switch ipVersion(network) { + case '4': + hints.Family = syscall.AF_INET + case '6': + hints.Family = syscall.AF_INET6 } + var result *syscall.AddrinfoW e := syscall.GetAddrInfoW(nil, syscall.StringToUTF16Ptr(service), &hints, &result) if e != nil { From cb2e189f9d9bf02f1d41f049c547f1c95b26def9 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Thu, 28 Sep 2023 18:18:09 +0200 Subject: [PATCH 02/11] update test Change-Id: I3e1cf4a2e7ced677d1968f33a987935c67321374 --- src/net/lookup_test.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 9720ba2ab44d8f..5c9ee0609feb7e 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1470,10 +1470,11 @@ func TestLookupPortNotFound(t *testing.T) { } func TestLookupPortDifferentNetwork(t *testing.T) { - // imaps service is only avilable with a tcp network, see: + // imaps service is only avilable through a tcp network, see: // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps _, err := LookupPort("udp", "imaps") - if dnsErr, ok := err.(*DNSError); !ok || !dnsErr.IsNotFound { + var dnsErr *DNSError + if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { t.Fatalf("unexpected error: %v", err) } } From 19e3b6f548f75a6a173058848dab71af567f65ac Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Thu, 28 Sep 2023 18:21:57 +0200 Subject: [PATCH 03/11] typo Change-Id: Ifbaff049826ef5b88dfe5c1a2df2d31178412022 --- src/net/lookup_windows.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/lookup_windows.go b/src/net/lookup_windows.go index 60709416b8dbf4..8c79bf1ac35586 100644 --- a/src/net/lookup_windows.go +++ b/src/net/lookup_windows.go @@ -209,7 +209,7 @@ func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int hints.Protocol = syscall.IPPROTO_TCP case "udp", "udp4", "udp6": hints.Socktype = syscall.SOCK_DGRAM - hints.Protocol = syscall.IPPROTO.UDP + hints.Protocol = syscall.IPPROTO_UDP default: return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} } From 1eda2b5350acbbc263fd769b22cfb95da1470536 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Thu, 28 Sep 2023 18:51:56 +0200 Subject: [PATCH 04/11] typo Change-Id: I44b8f34907fe212027b6ba5a7cfce4dfd2416fd8 --- src/net/lookup_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 5c9ee0609feb7e..ec3768d159d5d4 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1470,7 +1470,7 @@ func TestLookupPortNotFound(t *testing.T) { } func TestLookupPortDifferentNetwork(t *testing.T) { - // imaps service is only avilable through a tcp network, see: + // imaps service is only available through a tcp network, see: // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps _, err := LookupPort("udp", "imaps") var dnsErr *DNSError From a73f23adfd9bb38ef8423d31e2bab92d2606449b Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Fri, 29 Sep 2023 11:32:00 +0200 Subject: [PATCH 05/11] debugging Change-Id: I6ce84c62c786f7c96dd8848ffec30701789502dd --- src/net/cgo_unix.go | 2 +- src/net/lookup.go | 21 ++++++++++++---- src/net/lookup_test.go | 52 ++++++++++++++++++++++++++++++--------- src/net/lookup_windows.go | 1 + src/net/port_unix.go | 3 ++- 5 files changed, 60 insertions(+), 19 deletions(-) diff --git a/src/net/cgo_unix.go b/src/net/cgo_unix.go index 2a7d1ec3fafae3..0a783d08a9f15b 100644 --- a/src/net/cgo_unix.go +++ b/src/net/cgo_unix.go @@ -80,7 +80,7 @@ func cgoLookupHost(ctx context.Context, name string) (hosts []string, err error) func cgoLookupPort(ctx context.Context, network, service string) (port int, err error) { var hints _C_struct_addrinfo switch network { - case "": // no hints + case "ip": // no hints case "tcp", "tcp4", "tcp6": *_C_ai_socktype(&hints) = _C_SOCK_STREAM *_C_ai_protocol(&hints) = _C_IPPROTO_TCP diff --git a/src/net/lookup.go b/src/net/lookup.go index 28532075d4f7fc..cd509d1725a3af 100644 --- a/src/net/lookup.go +++ b/src/net/lookup.go @@ -83,12 +83,21 @@ const maxPortBufSize = len("mobility-header") + 10 func lookupPortMap(network, service string) (port int, error error) { switch network { - case "tcp4", "tcp6": - network = "tcp" - case "udp4", "udp6": - network = "udp" + case "ip": // no hints + if p, err := lookupPortMapWithNetwork("tcp", service); err == nil { + return p, nil + } + // TODO: error is wrong here (Name network) + return lookupPortMapWithNetwork("udp", service) + case "tcp", "tcp4", "tcp6": + return lookupPortMapWithNetwork("tcp", service) + case "udp", "udp4", "udp6": + return lookupPortMapWithNetwork("udp", service) } + return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} +} +func lookupPortMapWithNetwork(network, service string) (port int, error error) { if m, ok := services[network]; ok { var lowerService [maxPortBufSize]byte n := copy(lowerService[:], service) @@ -415,11 +424,13 @@ func LookupPort(network, service string) (port int, err error) { } // LookupPort looks up the port for the given network and service. +// +// The network must be one of "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6" or "ip". func (r *Resolver) LookupPort(ctx context.Context, network, service string) (port int, err error) { port, needsLookup := parsePort(service) if needsLookup { switch network { - case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6": + case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6", "ip": case "": // a hint wildcard for Go 1.0 undocumented behavior network = "ip" default: diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index ec3768d159d5d4..e7a719d57459ad 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1462,19 +1462,47 @@ func testLookupNoData(t *testing.T, prefix string) { } func TestLookupPortNotFound(t *testing.T) { - _, err := LookupPort("udp", "_-unknown-service-") - var dnsErr *DNSError - if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { - t.Fatalf("unexpected error: %v", err) - } + allResolvers(t, func(t *testing.T) { + _, err := LookupPort("udp", "_-unknown-service-") + var dnsErr *DNSError + if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { + t.Fatalf("unexpected error: %v", err) + } + }) } func TestLookupPortDifferentNetwork(t *testing.T) { - // imaps service is only available through a tcp network, see: - // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps - _, err := LookupPort("udp", "imaps") - var dnsErr *DNSError - if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { - t.Fatalf("unexpected error: %v", err) - } + allResolvers(t, func(t *testing.T) { + // imaps service is only available through a tcp network, see: + // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps + _, err := LookupPort("udp", "imaps") + var dnsErr *DNSError + if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { + // TODO remove, for debugging: + goLookupPort("tcp", "imaps") + t.Logf("services: %#v", services) + t.Fatalf("unexpected error: %v", err) + } + }) +} + +func TestLookupPortEmptyNetworkString(t *testing.T) { + allResolvers(t, func(t *testing.T) { + _, err := LookupPort("", "imaps") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + }) +} + +func allResolvers(t *testing.T, f func(t *testing.T)) { + t.Run("default resolver", f) + t.Run("forced go resolver", func(t *testing.T) { + defer forceGoDNS()() + f(t) + }) + t.Run("forced cgo resolver", func(t *testing.T) { + defer forceCgoDNS()() + f(t) + }) } diff --git a/src/net/lookup_windows.go b/src/net/lookup_windows.go index 8c79bf1ac35586..b6ef6da716edec 100644 --- a/src/net/lookup_windows.go +++ b/src/net/lookup_windows.go @@ -204,6 +204,7 @@ func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int var hints syscall.AddrinfoW switch network { + case "ip": // no hints case "tcp", "tcp4", "tcp6": hints.Socktype = syscall.SOCK_STREAM hints.Protocol = syscall.IPPROTO_TCP diff --git a/src/net/port_unix.go b/src/net/port_unix.go index df73dbabb3c25f..b16f079e70d780 100644 --- a/src/net/port_unix.go +++ b/src/net/port_unix.go @@ -2,7 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build unix || js || wasip1 +//TODO uncomment +////go:build unix || js || wasip1 // Read system port mappings from /etc/services From e5877491e113d68df830b682a4eac83f389d92c2 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Fri, 29 Sep 2023 12:04:14 +0200 Subject: [PATCH 06/11] change test service, remove debugs Change-Id: Ie8175208c23c8e6e3e70885432284b7192d3fb94 --- src/net/lookup.go | 42 +++++++++++++++++++++--------------------- src/net/lookup_test.go | 22 +++++++++++++++------- src/net/port_unix.go | 3 +-- 3 files changed, 37 insertions(+), 30 deletions(-) diff --git a/src/net/lookup.go b/src/net/lookup.go index cd509d1725a3af..15165970b6f38f 100644 --- a/src/net/lookup.go +++ b/src/net/lookup.go @@ -41,19 +41,20 @@ var services = map[string]map[string]int{ "domain": 53, }, "tcp": { - "ftp": 21, - "ftps": 990, - "gopher": 70, // ʕ◔ϖ◔ʔ - "http": 80, - "https": 443, - "imap2": 143, - "imap3": 220, - "imaps": 993, - "pop3": 110, - "pop3s": 995, - "smtp": 25, - "ssh": 22, - "telnet": 23, + "ftp": 21, + "ftps": 990, + "gopher": 70, // ʕ◔ϖ◔ʔ + "http": 80, + "https": 443, + "imap2": 143, + "imap3": 220, + "imaps": 993, + "pop3": 110, + "pop3s": 995, + "smtp": 25, + "submissions": 465, + "ssh": 22, + "telnet": 23, }, } @@ -84,20 +85,19 @@ const maxPortBufSize = len("mobility-header") + 10 func lookupPortMap(network, service string) (port int, error error) { switch network { case "ip": // no hints - if p, err := lookupPortMapWithNetwork("tcp", service); err == nil { + if p, err := lookupPortMapWithNetwork("tcp", "ip", service); err == nil { return p, nil } - // TODO: error is wrong here (Name network) - return lookupPortMapWithNetwork("udp", service) + return lookupPortMapWithNetwork("udp", "ip", service) case "tcp", "tcp4", "tcp6": - return lookupPortMapWithNetwork("tcp", service) + return lookupPortMapWithNetwork("tcp", "tcp", service) case "udp", "udp4", "udp6": - return lookupPortMapWithNetwork("udp", service) + return lookupPortMapWithNetwork("udp", "udp", service) } return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} } -func lookupPortMapWithNetwork(network, service string) (port int, error error) { +func lookupPortMapWithNetwork(network, errNetwork, service string) (port int, error error) { if m, ok := services[network]; ok { var lowerService [maxPortBufSize]byte n := copy(lowerService[:], service) @@ -105,9 +105,9 @@ func lookupPortMapWithNetwork(network, service string) (port int, error error) { if port, ok := m[string(lowerService[:n])]; ok && n == len(service) { return port, nil } - return 0, &DNSError{Err: "unknown port", Name: network + "/" + service, IsNotFound: true} + return 0, &DNSError{Err: "unknown port", Name: errNetwork + "/" + service, IsNotFound: true} } - return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} + return 0, &DNSError{Err: "unknown network", Name: errNetwork + "/" + service} } // ipVersion returns the provided network's IP version: '4', '6' or 0 diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index e7a719d57459ad..62322a81f3d250 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1471,16 +1471,15 @@ func TestLookupPortNotFound(t *testing.T) { }) } +// submissions service is only available through a tcp network, see: +// https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=submissions +const tcpOnlyService = "submissions" + func TestLookupPortDifferentNetwork(t *testing.T) { allResolvers(t, func(t *testing.T) { - // imaps service is only available through a tcp network, see: - // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=imaps - _, err := LookupPort("udp", "imaps") + _, err := LookupPort("udp", tcpOnlyService) var dnsErr *DNSError if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound { - // TODO remove, for debugging: - goLookupPort("tcp", "imaps") - t.Logf("services: %#v", services) t.Fatalf("unexpected error: %v", err) } }) @@ -1488,7 +1487,16 @@ func TestLookupPortDifferentNetwork(t *testing.T) { func TestLookupPortEmptyNetworkString(t *testing.T) { allResolvers(t, func(t *testing.T) { - _, err := LookupPort("", "imaps") + _, err := LookupPort("", tcpOnlyService) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + }) +} + +func TestLookupPortEmptyIPNetworkString(t *testing.T) { + allResolvers(t, func(t *testing.T) { + _, err := LookupPort("ip", tcpOnlyService) if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/src/net/port_unix.go b/src/net/port_unix.go index b16f079e70d780..df73dbabb3c25f 100644 --- a/src/net/port_unix.go +++ b/src/net/port_unix.go @@ -2,8 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//TODO uncomment -////go:build unix || js || wasip1 +//go:build unix || js || wasip1 // Read system port mappings from /etc/services From 30c7a6e4b0aec08c479772948e7a8e39db750a69 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Sat, 30 Sep 2023 20:12:13 +0200 Subject: [PATCH 07/11] check for nil fixup --- src/net/lookup_test.go | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 62322a81f3d250..74beb1315d3579 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1506,11 +1506,15 @@ func TestLookupPortEmptyIPNetworkString(t *testing.T) { func allResolvers(t *testing.T, f func(t *testing.T)) { t.Run("default resolver", f) t.Run("forced go resolver", func(t *testing.T) { - defer forceGoDNS()() - f(t) + if fixup := forceGoDNS(); fixup != nil { + defer fixup() + f(t) + } }) t.Run("forced cgo resolver", func(t *testing.T) { - defer forceCgoDNS()() - f(t) + if fixup := forceCgoDNS(); fixup != nil { + defer fixup() + f(t) + } }) } From f1abf40c3da427948c287ebc889cf359c1b7e706 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Sun, 1 Oct 2023 10:02:09 +0200 Subject: [PATCH 08/11] handle "ip" network on plan9 Change-Id: Icc1638d4af92dd3107829f0dda19ef800a441b25 --- src/net/lookup_plan9.go | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/src/net/lookup_plan9.go b/src/net/lookup_plan9.go index c9b4da951c96f9..9d2c4cda5bf53d 100644 --- a/src/net/lookup_plan9.go +++ b/src/net/lookup_plan9.go @@ -203,26 +203,36 @@ func (r *Resolver) lookupIP(ctx context.Context, network, host string) (addrs [] return } -func (*Resolver) lookupPort(ctx context.Context, network, service string) (port int, err error) { +func (r *Resolver) lookupPort(ctx context.Context, network, service string) (port int, err error) { switch network { - case "tcp4", "tcp6": - network = "tcp" - case "udp4", "udp6": - network = "udp" + case "ip": // no hints + if p, err := r.lookupPortWithNetwork(ctx, "tcp", "ip", service); err == nil { + return p, nil + } + return r.lookupPortWithNetwork(ctx, "udp", "ip", service) + case "tcp", "tcp4", "tcp6": + return r.lookupPortWithNetwork(ctx, "tcp", "tcp", service) + case "udp", "udp4", "udp6": + return r.lookupPortWithNetwork(ctx, "udp", "udp", service) + default: + return 0, &DNSError{Err: "unknown network", Name: network + "/" + service} } +} + +func (*Resolver) lookupPortWithNetwork(ctx context.Context, network, errNetwork, service string) (port int, err error) { lines, err := queryCS(ctx, network, "127.0.0.1", toLower(service)) if err != nil { if stringsHasSuffix(err.Error(), "can't translate service") { - return 0, &DNSError{Err: "unknown port", Name: network + "/" + service, IsNotFound: true} + return 0, &DNSError{Err: "unknown port", Name: errNetwork + "/" + service, IsNotFound: true} } return } if len(lines) == 0 { - return 0, &DNSError{Err: "unknown port", Name: network + "/" + service, IsNotFound: true} + return 0, &DNSError{Err: "unknown port", Name: errNetwork + "/" + service, IsNotFound: true} } f := getFields(lines[0]) if len(f) < 2 { - return 0, &DNSError{Err: "unknown port", Name: network + "/" + service, IsNotFound: true} + return 0, &DNSError{Err: "unknown port", Name: errNetwork + "/" + service, IsNotFound: true} } s := f[1] if i := bytealg.IndexByteString(s, '!'); i >= 0 { @@ -231,7 +241,7 @@ func (*Resolver) lookupPort(ctx context.Context, network, service string) (port if n, _, ok := dtoi(s); ok { return n, nil } - return 0, &DNSError{Err: "unknown port", Name: network + "/" + service, IsNotFound: true} + return 0, &DNSError{Err: "unknown port", Name: errNetwork + "/" + service, IsNotFound: true} } func (r *Resolver) lookupCNAME(ctx context.Context, name string) (cname string, err error) { From 4299a830b31ec2775933a93a299dc5656d539580 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Sun, 1 Oct 2023 11:13:12 +0200 Subject: [PATCH 09/11] fix test name Change-Id: I18d1dd6f113a89d0bedb70b0967f0bd8b74e4be2 --- src/net/lookup_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 74beb1315d3579..eb6588f4b28f88 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1494,7 +1494,7 @@ func TestLookupPortEmptyNetworkString(t *testing.T) { }) } -func TestLookupPortEmptyIPNetworkString(t *testing.T) { +func TestLookupPortIPNetworkString(t *testing.T) { allResolvers(t, func(t *testing.T) { _, err := LookupPort("ip", tcpOnlyService) if err != nil { From 5ddb7774993641d353308e00466307c3ab9281de Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Mon, 2 Oct 2023 16:50:55 +0200 Subject: [PATCH 10/11] use smtps on plan9 test Change-Id: I21db72b059e4ed702a406723cb4ea9fcfbb730cc --- src/net/lookup_test.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index eb6588f4b28f88..4e47c6c2cb060d 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1473,7 +1473,13 @@ func TestLookupPortNotFound(t *testing.T) { // submissions service is only available through a tcp network, see: // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=submissions -const tcpOnlyService = "submissions" +var tcpOnlyService = func() string { + // plan9 does not have submissions service defined in the service database. + if runtime.GOOS == "plan9" { + return "smtps" + } + return "submissions" +}() func TestLookupPortDifferentNetwork(t *testing.T) { allResolvers(t, func(t *testing.T) { From eaa616378b3fa9a5a72192f3d501c591804f45d8 Mon Sep 17 00:00:00 2001 From: Mateusz Poliwczak Date: Mon, 2 Oct 2023 18:19:20 +0200 Subject: [PATCH 11/11] use http service on plan9 Change-Id: Iaf2674302ccbb2e4c69e4d56c337f614c542b31f --- src/net/lookup_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 4e47c6c2cb060d..1e222763bd0d0d 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1476,7 +1476,7 @@ func TestLookupPortNotFound(t *testing.T) { var tcpOnlyService = func() string { // plan9 does not have submissions service defined in the service database. if runtime.GOOS == "plan9" { - return "smtps" + return "https" } return "submissions" }()