net: make InterfaceByIndex return a consistent name on solaris

Also retightens test cases for Resolve{TCP,UDP,IP}Addr which are using
interface names for specifying IPv6 zone.

Updates #14037.
Fixes #18362.

Change-Id: I7444b6302e2847dfbdab8a0ad5b2e702bed1a3d6
Reviewed-on: https://go-review.googlesource.com/34670
Run-TryBot: Mikio Hara <mikioh.mikioh@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/net/interface.go b/src/net/interface.go
index 301a5cfd223aaa8f96de9b1c72634966ec0cc768..b3297f249d6c41a9cee3083f12e6fb654088267b 100644 (file)
--- a/src/net/interface.go
+++ b/src/net/interface.go
@@ -172,6 +172,9 @@ func InterfaceByName(name string) (*Interface, error) {
 // An ipv6ZoneCache represents a cache holding partial network
 // interface information. It is used for reducing the cost of IPv6
 // addressing scope zone resolution.
+//
+// Multiple names sharing the index are managed by first-come
+// first-served basis for consistency.
 type ipv6ZoneCache struct {
        sync.RWMutex                // guard the following
        lastFetched  time.Time      // last time routing information was fetched
@@ -202,7 +205,9 @@ func (zc *ipv6ZoneCache) update(ift []Interface) {
        zc.toName = make(map[int]string, len(ift))
        for _, ifi := range ift {
                zc.toIndex[ifi.Name] = ifi.Index
-               zc.toName[ifi.Index] = ifi.Name
+               if _, ok := zc.toName[ifi.Index]; !ok {
+                       zc.toName[ifi.Index] = ifi.Name
+               }
        }
 }
 

diff --git a/src/net/iprawsock_test.go b/src/net/iprawsock_test.go
index 29cd4b6fd0d0352a7c6842a143cd3dfe82dd6e8d..5d33b26a91e0291b54ba232a176e6eaae6e28519 100644 (file)
--- a/src/net/iprawsock_test.go
+++ b/src/net/iprawsock_test.go
@@ -43,6 +43,13 @@ var resolveIPAddrTests = []resolveIPAddrTest{
        {"l2tp", "127.0.0.1", nil, UnknownNetworkError("l2tp")},
        {"l2tp:gre", "127.0.0.1", nil, UnknownNetworkError("l2tp:gre")},
        {"tcp", "1.2.3.4:123", nil, UnknownNetworkError("tcp")},
+
+       {"ip4", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
+       {"ip4:icmp", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
+       {"ip6", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
+       {"ip6", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
+       {"ip6:ipv6-icmp", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
+       {"ip6:ipv6-icmp", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
 }
 
 func TestResolveIPAddr(t *testing.T) {
@@ -54,21 +61,17 @@ func TestResolveIPAddr(t *testing.T) {
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupLocalhost
 
-       for i, tt := range resolveIPAddrTests {
+       for _, tt := range resolveIPAddrTests {
                addr, err := ResolveIPAddr(tt.network, tt.litAddrOrName)
-               if err != tt.err {
-                       t.Errorf("#%d: %v", i, err)
-               } else if !reflect.DeepEqual(addr, tt.addr) {
-                       t.Errorf("#%d: got %#v; want %#v", i, addr, tt.addr)
-               }
-               if err != nil {
+               if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
+                       t.Errorf("ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
                        continue
                }
-               rtaddr, err := ResolveIPAddr(addr.Network(), addr.String())
-               if err != nil {
-                       t.Errorf("#%d: %v", i, err)
-               } else if !reflect.DeepEqual(rtaddr, addr) {
-                       t.Errorf("#%d: got %#v; want %#v", i, rtaddr, addr)
+               if err == nil {
+                       addr2, err := ResolveIPAddr(addr.Network(), addr.String())
+                       if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
+                               t.Errorf("(%q, %q): ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
+                       }
                }
        }
 }

diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go
index 573e834911b74115389dcbca7ff372f80fe1722c..54bf0cfccc3a44979d5fde9a049a92ebb1f1c1d5 100644 (file)
--- a/src/net/tcpsock_test.go
+++ b/src/net/tcpsock_test.go
@@ -317,10 +317,11 @@ var resolveTCPAddrTests = []resolveTCPAddrTest{
        {"tcp", "[2001:db8::1]:http", &TCPAddr{IP: ParseIP("2001:db8::1"), Port: 80}, nil},
        {"tcp4", "127.0.0.1:http", &TCPAddr{IP: ParseIP("127.0.0.1"), Port: 80}, nil},
        {"tcp4", "[::ffff:127.0.0.1]:http", &TCPAddr{IP: ParseIP("127.0.0.1"), Port: 80}, nil},
+       {"tcp6", "[2001:db8::1]:http", &TCPAddr{IP: ParseIP("2001:db8::1"), Port: 80}, nil},
+
        {"tcp4", "[2001:db8::1]:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
        {"tcp6", "127.0.0.1:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
        {"tcp6", "[::ffff:127.0.0.1]:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
-       {"tcp6", "[2001:db8::1]:http", &TCPAddr{IP: ParseIP("2001:db8::1"), Port: 80}, nil},
 }
 
 func TestResolveTCPAddr(t *testing.T) {
@@ -331,13 +332,13 @@ func TestResolveTCPAddr(t *testing.T) {
        for _, tt := range resolveTCPAddrTests {
                addr, err := ResolveTCPAddr(tt.network, tt.litAddrOrName)
                if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
-                       t.Errorf("ResolveTCPAddr(%q, %q) = %v, %v, want %v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
+                       t.Errorf("ResolveTCPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
                        continue
                }
                if err == nil {
                        addr2, err := ResolveTCPAddr(addr.Network(), addr.String())
                        if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
-                               t.Errorf("(%q, %q): ResolveTCPAddr(%q, %q) = %v, %v, want %v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
+                               t.Errorf("(%q, %q): ResolveTCPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
                        }
                }
        }

diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index 29d769c5a5864076c93814aa8661afce347ace53..708cc10120912eacf04022e49d6e727fc8892fff 100644 (file)
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -72,6 +72,17 @@ var resolveUDPAddrTests = []resolveUDPAddrTest{
        {"udp", ":12345", &UDPAddr{Port: 12345}, nil},
 
        {"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
+
+       {"udp", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+       {"udp", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("::ffff:127.0.0.1"), Port: 53}, nil},
+       {"udp", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
+       {"udp4", "127.0.0.1:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+       {"udp4", "[::ffff:127.0.0.1]:domain", &UDPAddr{IP: ParseIP("127.0.0.1"), Port: 53}, nil},
+       {"udp6", "[2001:db8::1]:domain", &UDPAddr{IP: ParseIP("2001:db8::1"), Port: 53}, nil},
+
+       {"udp4", "[2001:db8::1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
+       {"udp6", "127.0.0.1:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
+       {"udp6", "[::ffff:127.0.0.1]:domain", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
 }
 
 func TestResolveUDPAddr(t *testing.T) {
@@ -79,21 +90,17 @@ func TestResolveUDPAddr(t *testing.T) {
        defer func() { testHookLookupIP = origTestHookLookupIP }()
        testHookLookupIP = lookupLocalhost
 
-       for i, tt := range resolveUDPAddrTests {
+       for _, tt := range resolveUDPAddrTests {
                addr, err := ResolveUDPAddr(tt.network, tt.litAddrOrName)
-               if err != tt.err {
-                       t.Errorf("#%d: %v", i, err)
-               } else if !reflect.DeepEqual(addr, tt.addr) {
-                       t.Errorf("#%d: got %#v; want %#v", i, addr, tt.addr)
-               }
-               if err != nil {
+               if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
+                       t.Errorf("ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
                        continue
                }
-               rtaddr, err := ResolveUDPAddr(addr.Network(), addr.String())
-               if err != nil {
-                       t.Errorf("#%d: %v", i, err)
-               } else if !reflect.DeepEqual(rtaddr, addr) {
-                       t.Errorf("#%d: got %#v; want %#v", i, rtaddr, addr)
+               if err == nil {
+                       addr2, err := ResolveUDPAddr(addr.Network(), addr.String())
+                       if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
+                               t.Errorf("(%q, %q): ResolveUDPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
+                       }
                }
        }
 }