2009-11-01 12:15:34 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
net, cmd/fix: add IPv6 scoped addressing zone to INET, INET6 address structs
This CL starts to introduce IPv6 scoped addressing capability
into the net package.
The Public API changes are:
+pkg net, type IPAddr struct, Zone string
+pkg net, type IPNet struct, Zone string
+pkg net, type TCPAddr struct, Zone string
+pkg net, type UDPAddr struct, Zone string
Update #4234.
R=rsc, bradfitz, iant
CC=golang-dev
https://golang.org/cl/6849045
2012-11-26 08:45:42 -07:00
|
|
|
// Internet protocol family sockets
|
2009-11-01 12:15:34 -07:00
|
|
|
|
|
|
|
package net
|
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"time"
|
|
|
|
)
|
2012-11-06 22:58:20 -07:00
|
|
|
|
2013-08-02 21:17:01 -06:00
|
|
|
var (
|
|
|
|
// supportsIPv4 reports whether the platform supports IPv4
|
|
|
|
// networking functionality.
|
|
|
|
supportsIPv4 bool
|
|
|
|
|
|
|
|
// supportsIPv6 reports whether the platfrom supports IPv6
|
|
|
|
// networking functionality.
|
|
|
|
supportsIPv6 bool
|
|
|
|
|
|
|
|
// supportsIPv4map reports whether the platform supports
|
|
|
|
// mapping an IPv4 address inside an IPv6 address at transport
|
|
|
|
// layer protocols. See RFC 4291, RFC 4038 and RFC 3493.
|
|
|
|
supportsIPv4map bool
|
|
|
|
)
|
2012-11-08 10:09:09 -07:00
|
|
|
|
|
|
|
func init() {
|
|
|
|
sysInit()
|
2013-08-02 21:17:01 -06:00
|
|
|
supportsIPv4 = probeIPv4Stack()
|
2012-11-08 10:09:09 -07:00
|
|
|
supportsIPv6, supportsIPv4map = probeIPv6Stack()
|
|
|
|
}
|
2011-05-16 15:03:06 -06:00
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
// A netaddr represents a network endpoint address or a list of
|
|
|
|
// network endpoint addresses.
|
|
|
|
type netaddr interface {
|
|
|
|
// toAddr returns the address represented in Addr interface.
|
|
|
|
// It returns a nil interface when the address is nil.
|
|
|
|
toAddr() Addr
|
|
|
|
}
|
|
|
|
|
2013-08-29 18:28:26 -06:00
|
|
|
// An addrList represents a list of network endpoint addresses.
|
|
|
|
type addrList []netaddr
|
|
|
|
|
|
|
|
func (al addrList) toAddr() Addr {
|
|
|
|
switch len(al) {
|
|
|
|
case 0:
|
|
|
|
return nil
|
|
|
|
case 1:
|
|
|
|
return al[0].toAddr()
|
|
|
|
default:
|
|
|
|
// For now, we'll roughly pick first one without
|
|
|
|
// considering dealing with any preferences such as
|
|
|
|
// DNS TTL, transport path quality, network routing
|
|
|
|
// information.
|
|
|
|
return al[0].toAddr()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
var errNoSuitableAddress = errors.New("no suitable address found")
|
|
|
|
|
|
|
|
// firstFavoriteAddr returns an address that implemets netaddr
|
|
|
|
// interface.
|
|
|
|
func firstFavoriteAddr(filter func(IP) IP, addrs []string, inetaddr func(IP) netaddr) (netaddr, error) {
|
2011-11-13 20:57:19 -07:00
|
|
|
if filter == nil {
|
undo CL 4557058 / b4c2ffae7034
Using the getaddrinfo order is only okay if we
are smart enough to try multiple addresses in Dial.
Since the code does not do that, we must make
the right first choice, regardless of what getaddrinfo
does, and more often that not that means using the
IPv4 address, even on IPv6 systems. With the CL
applied, gotest fails in package net on OS X.
helix.cam=; gotest
...
--- FAIL: net.TestDialGoogleIPv4 (1.05 seconds)
-- 74.125.226.179:80 --
-- www.google.com:80 --
Dial("tcp", "", "www.google.com:80") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 74.125.226.179:http --
-- www.google.com:http --
Dial("tcp", "", "www.google.com:http") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 074.125.226.179:0080 --
-- [::ffff:74.125.226.179]:80 --
-- [::ffff:4a7d:e2b3]:80 --
-- [0:0:0:0:0000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:000000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:0:ffff::74.125.226.179]:80 --
FAIL
gotest: "./6.out" failed: exit status 1
««« original CL description
net: name-based destination address selection
getaddrinfo() orders the addresses according to RFC 3484.
This means when IPv6 is working on a host we get results like:
[]string = {"2001:4810::110", "66.117.47.214"}
and when it's not working we get:
[]string = {"66.117.47.214", "2001:4810::110"}
thus can drop firstFavoriteAddr.
This also means /etc/gai.conf works on relevant systems.
R=rsc, mikioh.mikioh
CC=golang-dev
https://golang.org/cl/4557058
»»»
R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/4532101
2011-06-01 13:49:57 -06:00
|
|
|
// We'll take any IP address, but since the dialing code
|
|
|
|
// does not yet try multiple addresses, prefer to use
|
|
|
|
// an IPv4 address if possible. This is especially relevant
|
|
|
|
// if localhost resolves to [ipv6-localhost, ipv4-localhost].
|
|
|
|
// Too much code assumes localhost == ipv4-localhost.
|
2013-08-29 18:09:45 -06:00
|
|
|
addr, err := firstSupportedAddr(ipv4only, addrs, inetaddr)
|
|
|
|
if err != nil {
|
|
|
|
addr, err = firstSupportedAddr(anyaddr, addrs, inetaddr)
|
undo CL 4557058 / b4c2ffae7034
Using the getaddrinfo order is only okay if we
are smart enough to try multiple addresses in Dial.
Since the code does not do that, we must make
the right first choice, regardless of what getaddrinfo
does, and more often that not that means using the
IPv4 address, even on IPv6 systems. With the CL
applied, gotest fails in package net on OS X.
helix.cam=; gotest
...
--- FAIL: net.TestDialGoogleIPv4 (1.05 seconds)
-- 74.125.226.179:80 --
-- www.google.com:80 --
Dial("tcp", "", "www.google.com:80") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 74.125.226.179:http --
-- www.google.com:http --
Dial("tcp", "", "www.google.com:http") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 074.125.226.179:0080 --
-- [::ffff:74.125.226.179]:80 --
-- [::ffff:4a7d:e2b3]:80 --
-- [0:0:0:0:0000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:000000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:0:ffff::74.125.226.179]:80 --
FAIL
gotest: "./6.out" failed: exit status 1
««« original CL description
net: name-based destination address selection
getaddrinfo() orders the addresses according to RFC 3484.
This means when IPv6 is working on a host we get results like:
[]string = {"2001:4810::110", "66.117.47.214"}
and when it's not working we get:
[]string = {"66.117.47.214", "2001:4810::110"}
thus can drop firstFavoriteAddr.
This also means /etc/gai.conf works on relevant systems.
R=rsc, mikioh.mikioh
CC=golang-dev
https://golang.org/cl/4557058
»»»
R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/4532101
2011-06-01 13:49:57 -06:00
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
return addr, err
|
undo CL 4557058 / b4c2ffae7034
Using the getaddrinfo order is only okay if we
are smart enough to try multiple addresses in Dial.
Since the code does not do that, we must make
the right first choice, regardless of what getaddrinfo
does, and more often that not that means using the
IPv4 address, even on IPv6 systems. With the CL
applied, gotest fails in package net on OS X.
helix.cam=; gotest
...
--- FAIL: net.TestDialGoogleIPv4 (1.05 seconds)
-- 74.125.226.179:80 --
-- www.google.com:80 --
Dial("tcp", "", "www.google.com:80") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 74.125.226.179:http --
-- www.google.com:http --
Dial("tcp", "", "www.google.com:http") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 074.125.226.179:0080 --
-- [::ffff:74.125.226.179]:80 --
-- [::ffff:4a7d:e2b3]:80 --
-- [0:0:0:0:0000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:000000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:0:ffff::74.125.226.179]:80 --
FAIL
gotest: "./6.out" failed: exit status 1
««« original CL description
net: name-based destination address selection
getaddrinfo() orders the addresses according to RFC 3484.
This means when IPv6 is working on a host we get results like:
[]string = {"2001:4810::110", "66.117.47.214"}
and when it's not working we get:
[]string = {"66.117.47.214", "2001:4810::110"}
thus can drop firstFavoriteAddr.
This also means /etc/gai.conf works on relevant systems.
R=rsc, mikioh.mikioh
CC=golang-dev
https://golang.org/cl/4557058
»»»
R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/4532101
2011-06-01 13:49:57 -06:00
|
|
|
} else {
|
2013-08-29 18:09:45 -06:00
|
|
|
return firstSupportedAddr(filter, addrs, inetaddr)
|
undo CL 4557058 / b4c2ffae7034
Using the getaddrinfo order is only okay if we
are smart enough to try multiple addresses in Dial.
Since the code does not do that, we must make
the right first choice, regardless of what getaddrinfo
does, and more often that not that means using the
IPv4 address, even on IPv6 systems. With the CL
applied, gotest fails in package net on OS X.
helix.cam=; gotest
...
--- FAIL: net.TestDialGoogleIPv4 (1.05 seconds)
-- 74.125.226.179:80 --
-- www.google.com:80 --
Dial("tcp", "", "www.google.com:80") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 74.125.226.179:http --
-- www.google.com:http --
Dial("tcp", "", "www.google.com:http") = _, dial tcp [2001:4860:800f::69]:80: address family not supported by protocol family
-- 074.125.226.179:0080 --
-- [::ffff:74.125.226.179]:80 --
-- [::ffff:4a7d:e2b3]:80 --
-- [0:0:0:0:0000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:000000:ffff:74.125.226.179]:80 --
-- [0:0:0:0:0:ffff::74.125.226.179]:80 --
FAIL
gotest: "./6.out" failed: exit status 1
««« original CL description
net: name-based destination address selection
getaddrinfo() orders the addresses according to RFC 3484.
This means when IPv6 is working on a host we get results like:
[]string = {"2001:4810::110", "66.117.47.214"}
and when it's not working we get:
[]string = {"66.117.47.214", "2001:4810::110"}
thus can drop firstFavoriteAddr.
This also means /etc/gai.conf works on relevant systems.
R=rsc, mikioh.mikioh
CC=golang-dev
https://golang.org/cl/4557058
»»»
R=golang-dev, bradfitz
CC=golang-dev
https://golang.org/cl/4532101
2011-06-01 13:49:57 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
func firstSupportedAddr(filter func(IP) IP, addrs []string, inetaddr func(IP) netaddr) (netaddr, error) {
|
2011-02-16 13:05:48 -07:00
|
|
|
for _, s := range addrs {
|
2013-08-29 18:09:45 -06:00
|
|
|
if ip := filter(ParseIP(s)); ip != nil {
|
|
|
|
return inetaddr(ip), nil
|
2011-02-16 13:05:48 -07:00
|
|
|
}
|
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
return nil, errNoSuitableAddress
|
2011-04-20 13:21:59 -06:00
|
|
|
}
|
|
|
|
|
2013-08-02 21:17:01 -06:00
|
|
|
// anyaddr returns IP addresses that we can use with the current
|
|
|
|
// kernel configuration. It returns nil when ip is not suitable for
|
|
|
|
// the configuration and an IP address.
|
|
|
|
func anyaddr(ip IP) IP {
|
|
|
|
if ip4 := ipv4only(ip); ip4 != nil {
|
|
|
|
return ip4
|
2011-05-16 15:03:06 -06:00
|
|
|
}
|
2013-08-02 21:17:01 -06:00
|
|
|
return ipv6only(ip)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ipv4only returns IPv4 addresses that we can use with the kernel's
|
|
|
|
// IPv4 addressing modes. It returns IPv4-mapped IPv6 addresses as
|
|
|
|
// IPv4 addresses and returns other IPv6 address types as nils.
|
|
|
|
func ipv4only(ip IP) IP {
|
|
|
|
if supportsIPv4 {
|
|
|
|
return ip.To4()
|
2011-05-16 15:03:06 -06:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-08-02 21:17:01 -06:00
|
|
|
// ipv6only returns IPv6 addresses that we can use with the kernel's
|
|
|
|
// IPv6 addressing modes. It returns IPv4-mapped IPv6 addresses as
|
|
|
|
// nils and returns other IPv6 address types as IPv6 addresses.
|
|
|
|
func ipv6only(ip IP) IP {
|
|
|
|
if supportsIPv6 && len(ip) == IPv6len && ip.To4() == nil {
|
|
|
|
return ip
|
2011-04-20 13:21:59 -06:00
|
|
|
}
|
2011-05-16 15:03:06 -06:00
|
|
|
return nil
|
2011-02-16 13:05:48 -07:00
|
|
|
}
|
|
|
|
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
// SplitHostPort splits a network address of the form "host:port",
|
|
|
|
// "[host]:port" or "[ipv6-host%zone]:port" into host or
|
|
|
|
// ipv6-host%zone and port. A literal address or host name for IPv6
|
|
|
|
// must be enclosed in square brackets, as in "[::1]:80",
|
|
|
|
// "[ipv6-host]:http" or "[ipv6-host%zone]:80".
|
2011-11-01 20:05:34 -06:00
|
|
|
func SplitHostPort(hostport string) (host, port string, err error) {
|
2013-01-30 10:25:16 -07:00
|
|
|
j, k := 0, 0
|
|
|
|
|
2009-11-01 12:15:34 -07:00
|
|
|
// The port starts after the last colon.
|
2009-12-15 16:35:38 -07:00
|
|
|
i := last(hostport, ':')
|
2009-11-01 12:15:34 -07:00
|
|
|
if i < 0 {
|
2013-01-30 10:25:16 -07:00
|
|
|
goto missingPort
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2013-01-30 10:25:16 -07:00
|
|
|
|
|
|
|
if hostport[0] == '[' {
|
|
|
|
// Expect the first ']' just before the last ':'.
|
|
|
|
end := byteIndex(hostport, ']')
|
|
|
|
if end < 0 {
|
|
|
|
err = &AddrError{"missing ']' in address", hostport}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
switch end + 1 {
|
|
|
|
case len(hostport):
|
|
|
|
// There can't be a ':' behind the ']' now.
|
|
|
|
goto missingPort
|
|
|
|
case i:
|
|
|
|
// The expected result.
|
|
|
|
default:
|
|
|
|
// Either ']' isn't followed by a colon, or it is
|
|
|
|
// followed by a colon that is not the last one.
|
|
|
|
if hostport[end+1] == ':' {
|
|
|
|
goto tooManyColons
|
|
|
|
}
|
|
|
|
goto missingPort
|
|
|
|
}
|
|
|
|
host = hostport[1:end]
|
|
|
|
j, k = 1, end+1 // there can't be a '[' resp. ']' before these positions
|
2009-11-01 12:15:34 -07:00
|
|
|
} else {
|
2013-01-30 10:25:16 -07:00
|
|
|
host = hostport[:i]
|
2009-11-01 12:15:34 -07:00
|
|
|
if byteIndex(host, ':') >= 0 {
|
2013-01-30 10:25:16 -07:00
|
|
|
goto tooManyColons
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
if byteIndex(host, '%') >= 0 {
|
|
|
|
goto missingBrackets
|
|
|
|
}
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2013-01-30 10:25:16 -07:00
|
|
|
if byteIndex(hostport[j:], '[') >= 0 {
|
|
|
|
err = &AddrError{"unexpected '[' in address", hostport}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if byteIndex(hostport[k:], ']') >= 0 {
|
|
|
|
err = &AddrError{"unexpected ']' in address", hostport}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
port = hostport[i+1:]
|
|
|
|
return
|
|
|
|
|
|
|
|
missingPort:
|
|
|
|
err = &AddrError{"missing port in address", hostport}
|
|
|
|
return
|
|
|
|
|
|
|
|
tooManyColons:
|
|
|
|
err = &AddrError{"too many colons in address", hostport}
|
2009-12-15 16:35:38 -07:00
|
|
|
return
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
|
|
|
|
missingBrackets:
|
|
|
|
err = &AddrError{"missing brackets in address", hostport}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func splitHostZone(s string) (host, zone string) {
|
|
|
|
// The IPv6 scoped addressing zone identifer starts after the
|
|
|
|
// last percent sign.
|
|
|
|
if i := last(s, '%'); i > 0 {
|
|
|
|
host, zone = s[:i], s[i+1:]
|
|
|
|
} else {
|
|
|
|
host = s
|
|
|
|
}
|
|
|
|
return
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
|
|
|
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
// JoinHostPort combines host and port into a network address of the
|
|
|
|
// form "host:port" or, if host contains a colon or a percent sign,
|
|
|
|
// "[host]:port".
|
2011-03-28 21:28:42 -06:00
|
|
|
func JoinHostPort(host, port string) string {
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
// If host has colons or a percent sign, have to bracket it.
|
|
|
|
if byteIndex(host, ':') >= 0 || byteIndex(host, '%') >= 0 {
|
2009-11-09 22:23:52 -07:00
|
|
|
return "[" + host + "]:" + port
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return host + ":" + port
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
// resolveInternetAddr resolves addr that is either a literal IP
|
|
|
|
// address or a DNS registered name and returns an internet protocol
|
|
|
|
// family address.
|
|
|
|
func resolveInternetAddr(net, addr string, deadline time.Time) (netaddr, error) {
|
2012-11-27 14:36:05 -07:00
|
|
|
var (
|
|
|
|
err error
|
|
|
|
host, port, zone string
|
|
|
|
portnum int
|
|
|
|
)
|
|
|
|
switch net {
|
|
|
|
case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
|
|
|
|
if addr != "" {
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
if host, port, err = SplitHostPort(addr); err != nil {
|
2012-11-27 14:36:05 -07:00
|
|
|
return nil, err
|
2009-11-02 19:37:30 -07:00
|
|
|
}
|
2012-11-27 14:36:05 -07:00
|
|
|
if portnum, err = parsePort(net, port); err != nil {
|
|
|
|
return nil, err
|
2009-11-02 19:37:30 -07:00
|
|
|
}
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2012-11-27 14:36:05 -07:00
|
|
|
case "ip", "ip4", "ip6":
|
|
|
|
if addr != "" {
|
|
|
|
host = addr
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return nil, UnknownNetworkError(net)
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
inetaddr := func(ip IP) netaddr {
|
2012-11-27 14:36:05 -07:00
|
|
|
switch net {
|
|
|
|
case "tcp", "tcp4", "tcp6":
|
2013-08-29 18:09:45 -06:00
|
|
|
return &TCPAddr{IP: ip, Port: portnum, Zone: zone}
|
2012-11-27 14:36:05 -07:00
|
|
|
case "udp", "udp4", "udp6":
|
2013-08-29 18:09:45 -06:00
|
|
|
return &UDPAddr{IP: ip, Port: portnum, Zone: zone}
|
2012-11-27 14:36:05 -07:00
|
|
|
case "ip", "ip4", "ip6":
|
|
|
|
return &IPAddr{IP: ip, Zone: zone}
|
2013-08-29 18:09:45 -06:00
|
|
|
default:
|
|
|
|
panic("unexpected network: " + net)
|
2012-11-27 14:36:05 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if host == "" {
|
2013-08-29 18:09:45 -06:00
|
|
|
return inetaddr(nil), nil
|
2012-11-27 14:36:05 -07:00
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
// Try as a literal IP address.
|
|
|
|
var ip IP
|
|
|
|
if ip = parseIPv4(host); ip != nil {
|
|
|
|
return inetaddr(ip), nil
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
if ip, zone = parseIPv6(host, true); ip != nil {
|
|
|
|
return inetaddr(ip), nil
|
2012-11-27 14:36:05 -07:00
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
// Try as a DNS registered name.
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
host, zone = splitHostZone(host)
|
|
|
|
addrs, err := lookupHostDeadline(host, deadline)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2012-11-27 14:36:05 -07:00
|
|
|
var filter func(IP) IP
|
|
|
|
if net != "" && net[len(net)-1] == '4' {
|
|
|
|
filter = ipv4only
|
|
|
|
}
|
net: support IPv6 scoped addressing zone
This CL provides IPv6 scoped addressing zone support as defined
in RFC 4007 for internet protocol family connection setups.
Follwoing types and functions allow a literal IPv6 address with
zone identifer as theirs parameter.
pkg net, func Dial(string, string) (Conn, error)
pkg net, func DialOpt(string, ...DialOption) (Conn, error)
pkg net, func DialTimeout(string, string, time.Duration) (Conn, error)
pkg net, func Listen(string, string) (Listener, error)
pkg net, func ListenPacket(string, string) (PacketConn, error)
pkg net, func ResolveIPAddr(string, string) (*IPAddr, error)
pkg net, func ResolveTCPAddr(string, string) (*TCPAddr, error)
pkg net, func ResolveUDPAddr(string, string) (*UDPAddr, error)
pkg net, type IPAddr struct, Zone string
pkg net, type TCPAddr struct, Zone string
pkg net, type UDPAddr struct, Zone string
Also follwoing methods return a literal IPv6 address with zone
identifier string if possible.
pkg net, method (*IPAddr) String() string
pkg net, method (*TCPAddr) String() string
pkg net, method (*UDPAddr) String() string
Fixes #4234.
Fixes #4501.
Update #5081.
R=rsc, iant
CC=golang-dev
https://golang.org/cl/6816116
2013-03-22 18:57:40 -06:00
|
|
|
if net != "" && net[len(net)-1] == '6' || zone != "" {
|
2012-11-27 14:36:05 -07:00
|
|
|
filter = ipv6only
|
|
|
|
}
|
2013-08-29 18:09:45 -06:00
|
|
|
return firstFavoriteAddr(filter, addrs, inetaddr)
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
net, cmd/fix: add IPv6 scoped addressing zone to INET, INET6 address structs
This CL starts to introduce IPv6 scoped addressing capability
into the net package.
The Public API changes are:
+pkg net, type IPAddr struct, Zone string
+pkg net, type IPNet struct, Zone string
+pkg net, type TCPAddr struct, Zone string
+pkg net, type UDPAddr struct, Zone string
Update #4234.
R=rsc, bradfitz, iant
CC=golang-dev
https://golang.org/cl/6849045
2012-11-26 08:45:42 -07:00
|
|
|
|
|
|
|
func zoneToString(zone int) string {
|
|
|
|
if zone == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if ifi, err := InterfaceByIndex(zone); err == nil {
|
|
|
|
return ifi.Name
|
|
|
|
}
|
|
|
|
return itod(uint(zone))
|
|
|
|
}
|
|
|
|
|
|
|
|
func zoneToInt(zone string) int {
|
|
|
|
if zone == "" {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
if ifi, err := InterfaceByName(zone); err == nil {
|
|
|
|
return ifi.Index
|
|
|
|
}
|
|
|
|
n, _, _ := dtoi(zone, 0)
|
|
|
|
return n
|
|
|
|
}
|