/cc @mikioh for thoughts

I suppose that the existing Dialer is designed for handling a single pair of DNS reg-name and address literal or address literals. For handling multiple address families, endpoints and subflows, I'd prefer a new API rather than modifying the existing Dialer, the same as #9334.

I don't think we want to add more dialing API when we already have Dialer. Dialer seems like the natural place to extend, and was made exactly to provide a place to extend.

Fair enough.

@bong0,

Can you please elaborate on your problem?

• What's your use case?
• Why do you need to specify multiple addresses?
• Does the list of addresses need to support multiple address families?

In general, the additional fields would look like the following:

type Dialer struct {
        // A list of source address candidates for TCP and UDP connections.
        LocalAddrs []Addr

        // For verifying/specifying the addressing scope of LocalAddr and LocalAddrs.
        // Moreover, when LocalAddr and LocalAddrs are empty,
        // source address candidates will be chosen from LocalInterfaces.
        // When the destination address scope is less than or equal to link-local,
        // LocalInterfaces must not contain multiple interfaces. 
        LocalInterfaces []Interface
}

Most hard part would be to write test cases and to prepare test environment.

@mikioh sure.
Usecase+Why I need multiple addresses:
Let's take the following example (http://play.golang.org/p/avpRdQNaW8)

I set my LocalAddr to a IPv4 Address assigned to one local interface 192.168.0.99.

func main(){

        localAddr := &net.TCPAddr{
                IP: net.ParseIP("192.168.0.99"), // a secondary local IP I assigned to me
        }

I configure the client to use it:

        client := &http.Client{}
        client.Transport = &http.Transport{
                Dial: (func(network, addr string) (net.Conn, error) {
                        return (&net.Dialer{
                                Timeout:        3 * time.Second,
                                LocalAddr:      nil,
                                DualStack:      false,

... and decide also to accept connections to ipv6 hosts ("tcp" instead of "tcp4")

                        }).Dial("tcp", addr)
                }),
        }

        fmt.Println("local ip to connect", localAddr.IP)

I connect to a IPv6 only host:

        resp,err := client.Get("http://6.ifcfg.me/")
        if err != nil {
                fmt.Println(err)
                return
        }
        a, err := ioutil.ReadAll(resp.Body)
        if err != nil {
                fmt.Println(err)
        } else {
                fmt.Println("actual ip used: ",string(a))
        }
}

... which succeeds ("fallback" to ipv6) but uses an IP address I could not choose, since I could only specify one LocalAddr for one IP family.

I do not know in advance whether a host is ipv6 only and I want to prefer v4 if it's supported. I do not want to use any ipv6 address to connect.
(The same goes for setting a v6 as LocalAddr and not wanting to connect over an arbitrary v4)

To your Question "Does the list of addresses need to support multiple address families?":

• Yes if we follow the design of an n-tuple of LocalAddresses from which a random one gets chosen (depending on which addressfamily is needed)

I think you misunderstand what Dialer.DualStack is. It just enables "Happy Eyeballs" dialing defined in RFC 6555. Even if DualStack is false, Dialer.Dial tries to connect a list of destination addresses when network is "tcp".

I'm still not sure what you want to do, but it looks like you simply want to prefer IPv4 to IPv6. If so, you can write your favorite dial function like the following:

tr := http.Transport{Dial: myDial}
srcs := []net.TCPAddr{
        {IP: ...},
        {IP: ...},
}

func myDial(network, addr string) (c net.Conn, err error) {
        host, port, err := net.SplitHostPort(addr)
        if err != nil {
                return nil, err
        }
        ips, err := net.LookupIP(host)
        if err != nil {
                return nil, err
        }
        d := net.Dialer{Timeout: 3 * time.Second}
        var fallbacks []net.IP
        for _, ip := range ips {
                if ip.To4() != nil {
                        for _, src := range srcs {
                                d.LocalAddr = &src
                                c, err = d.Dial("tcp4", addr)
                                if err != nil {
                                        continue
                                }
                                return
                        }
                }
                if ip.To16() != nil && ip.To4() == nil {
                        fallbacks = append(fallbacks, ip)
                }
        }
        for _, ip := range fallbacks {
                d.LocalAddr = nil
                c, err = d.Dial("tcp6", net.JoinHostPort(ip.String(), port))
                if err != nil {
                        continue
                }
                return
        }
        return nil, errors.New("oops")
}

I suppose that what @bong0 wants is just to make Dialer.Dial("tcp", "DNS reg-name") prefer IPv4 to IPv6 or vice versa without writing own connection setup logic. I'm not sure whether adding LocalAddrs and LocalInterfaces to Dialer is sufficient to achieve that purpose.

@mikioh sorry for the delay. I looked at your proposal and it sort of solves what I want to do in the end (just not such a low level).

If #16672 were implemented, could you just do it yourself?

Now that we have a Resolver type, this could be done pretty easily with options on a Resolver. Ping @bradfitz.

Add two bools, PreferIPv4 and PreferIPv6 to the new *net.Resolver type?

Does Resolver.PreferIPv4 give preference to A-record or preference to IPv4 DNS transport, or both?

Go 1.8 will introduce a net.Resolver type that lets you do a name resolution with a timeout (or if you don't care about a timeout, Go 1.7 already had that), so you could do the conversion from host name to IP addresses with (*Resolver).LookupHost and then prioritize the results however you like, including by starting some v4 attempts and then timing out or kicking off new v6 attempts after a certain time. It doesn't seem like Dialer or anything else in package net needs to change to support this.

Please reopen if this doesn't solve your use case. Thanks.