dns: scoped literal IPv6 addresses should be supported

[menghanl]

fe80::1ff:fe23:4567:890a%eth2 is a valid IPv6 address, and should be supported in the DNS resolver

net.Dial("dns:///fe80::1ff:fe23:4567:890a%eth2:8080")

It fails with ParseIP error now.

https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses

[menghanl]

Literal IPv6 addresses with zone identifer are supported by functions like net.Dial (golang/go@aa0dda7), but not net.ParseIP. The default DNS resolver also supports this address.

A work-around now is to use passthrough as the resolver.

To solve this in the DNS resolver, we can remove the special code for IPs (so we don't call ParseIP), and let the default go DNS resolver handle everything.

[xujianhai666]

use [fdbd:dc02:ff:1:1:225:111:82]:9238 format will resolve

[jackwener]

The issue is interesting, I'm willing to take this task up.

[jackwener]

@menghanl After I read code and your instruction, I think the solution is to remove net.ParseIP in formatIP but remain net.ParseIP in parseTarget. Is this right?

grpc-go/internal/resolver/dns/dns_resolver.go

Line 364 in a42567f

ip := net.ParseIP(addr)

grpc-go/internal/resolver/dns/dns_resolver.go

Line 387 in a42567f

if ip := net.ParseIP(target); ip != nil {

[jackwener]

It's not enough to remove net.ParseIP, because address will be not verified.
We could still use ParseIP for verifying if it is in high version.

parseIPv6 support literal IPv6

[jackwener]

OMG，the solution above is wrong.
The solution is removing the IP resolver , and let the default go DNS resolver handle everything.
However, customAuthorityResolver call formatIP and parseTarget.
There is still some wrong.

[menghanl]

I don't remember all the details about this issue.
But I think if we want to keep our handling of IPs, we can update formatIP and parseTarget to handle scopes.

Seems it's as easy as finding the %: https://cs.opensource.google/go/go/+/refs/tags/go1.17:src/net/ip.go;l=592

If the DNS resolver can recognize this address, it can just return it as is, and net.Dial will handle it correctly.

Note that in ParseIP (and when used with gRPC), the address should be put in brackets dns:///[fe80::1ff:fe23:4567:890a%eth2]:8080

[jackwener]

Yes, I notice that dns:///[fe80::1ff:fe23:4567:890a%eth2]:8080 is supported instead of net.Dial("dns:///fe80::1ff:fe23:4567:890a%eth2:8080")

[gknw]

Is there any solution for grpc.Dial to connect to ipv6 with scope? Maybe example? Now with passthrough returns error invalid URL escape

[gknw]

Works for me:

tcp:[fe80::1ff:fe23:4567:890a%25eth2]:8080

url.Parse issue: golang/go#30611

rfc6874:

In a URI, a literal IPv6 address is always embedded between "[" and
   "]".  This document specifies how a <zone_id> can be appended to the
   address.  According to URI syntax [[RFC3986](https://www.rfc-editor.org/rfc/rfc3986)], "%" is always treated as
   an escape character in a URI, so, according to the established URI
   syntax [[RFC3986](https://www.rfc-editor.org/rfc/rfc3986)] any occurrences of literal "%" symbols in a URI MUST
   be percent-encoded and represented in the form "%25".  Thus, the
   scoped address fe80::a%en1 would appear in a URI as
   http://[fe80::a%25en1].

[easwars]

Given that the net package now supports parsing of IPv6 scoped literals, all we need to do is to ensure that this actually works for us, and to have a test for the same. Before that (or as part of that) though, we need to cleanup dns_resolver_test.go, which is currently a mess.

[hanut19]

@purnesh42H assign to me

[hanut19]

@purnesh42H this works for ipv6 with below format
ipv6Address := "[2001:4860:4860::8888]:80"
// Dial the IPv6 address
conn, err := net.Dial("tcp", ipv6Address)

[easwars]

Before that (or as part of that) though, we need to cleanup dns_resolver_test.go, which is currently a mess.

We did this as part of some other effort. So, these tests are reasonably OK.

this works for ipv6 with below format
ipv6Address := "[2001:4860:4860::8888]:80"

That's good to know. We need to have a unit test for this.

[purnesh42H]

Thanks @hanut19. Could you write a unit test for the ipv6Address := "[2001:4860:4860::8888]:80" case

[hanut19]

@purnesh42H please review hanut19#1

[easwars]

@purnesh42H please review hanut19#1

@hanut19 : Is there a reason to send a pull request on your fork instead of on master?

[hanut19]

@purnesh42H please review hanut19#1

@hanut19 : Is there a reason to send a pull request on your fork instead of on master?

purnesh told as to do in this way.

[hanut19]

@purnesh42H @easwars
I tried the literal ip address "dns:///[fe80::1ff:fe23:4567:890a%eth2]:8080" but parsing failed?

we should try to fix it in our parsing logic.

[easwars]

Based on #3272 (comment), the % needs to be escaped. So, dns:///[fe80::1ff:fe23:4567:890a%eth2]:8080 would be dns:///[fe80::1ff:fe23:4567:890a%25eth2]:8080 actually. Maybe we need to escape the URI before calling net.Dial. Could you please try that? Thanks

[purnesh42H]

@hanut19 please test net.ParseIP for [fe80::1ff:fe23:4567:890a%eth2] with % escaped and update here

[hanut19]

@purnesh42H net.ParseIP unable to parse this [fe80::1ff:fe23:4567:890a%eth2] with % escaped.

address := "[fe80::1ff:fe23:4567:890a%eth2]"

Escaped using the following methods:

1. strings.ReplaceAll(address, "%", "%25")
2. url.QueryEscape(address)