bump deps

third_party/code.google.com/p/go.net/ipv4/mocktransponder_test.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build darwin freebsd linux netbsd openbsd
-
 package ipv4_test
 
 import (
@@ -75,6 +73,10 @@ func writeThenReadDatagram(t *testing.T, i int, c *ipv4.RawConn, wb []byte, src,
 	return b
 }
 
+func isUnicast(ip net.IP) bool {
+	return ip.To4() != nil && (ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsGlobalUnicast())
+}
+
 // LoopbackInterface returns a logical network interface for loopback
 // tests.
 func loopbackInterface() *net.Interface {
@@ -83,8 +85,24 @@ func loopbackInterface() *net.Interface {
 		return nil
 	}
 	for _, ifi := range ift {
-		if ifi.Flags&net.FlagLoopback != 0 {
-			return &ifi
+		if ifi.Flags&net.FlagLoopback == 0 || ifi.Flags&net.FlagUp == 0 {
+			continue
+		}
+		ifat, err := ifi.Addrs()
+		if err != nil {
+			continue
+		}
+		for _, ifa := range ifat {
+			switch ifa := ifa.(type) {
+			case *net.IPAddr:
+				if isUnicast(ifa.IP) {
+					return &ifi
+				}
+			case *net.IPNet:
+				if isUnicast(ifa.IP) {
+					return &ifi
+				}
+			}
 		}
 	}
 	return nil
@@ -94,31 +112,24 @@ func loopbackInterface() *net.Interface {
 // enabled network interface.  It also returns a unicast IPv4 address
 // that can be used for listening on ifi.
 func isMulticastAvailable(ifi *net.Interface) (net.IP, bool) {
-	if ifi.Flags&net.FlagUp == 0 || ifi.Flags&net.FlagMulticast == 0 {
+	if ifi == nil || ifi.Flags&net.FlagUp == 0 || ifi.Flags&net.FlagMulticast == 0 {
 		return nil, false
 	}
 	ifat, err := ifi.Addrs()
 	if err != nil {
 		return nil, false
 	}
-	if len(ifat) == 0 {
-		return nil, false
-	}
-	var ip net.IP
 	for _, ifa := range ifat {
-		switch v := ifa.(type) {
+		switch ifa := ifa.(type) {
 		case *net.IPAddr:
-			ip = v.IP
+			if isUnicast(ifa.IP) {
+				return ifa.IP, true
+			}
 		case *net.IPNet:
-			ip = v.IP
-		default:
-			continue
+			if isUnicast(ifa.IP) {
+				return ifa.IP, true
+			}
 		}
-		if ip.To4() == nil {
-			ip = nil
-			continue
-		}
-		break
 	}
-	return ip, true
+	return nil, false
 }

third_party/code.google.com/p/go.net/ipv4/multicastlistener_test.go

@@ -2,41 +2,41 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build darwin freebsd linux netbsd openbsd
-
 package ipv4_test
 
 import (
 	"code.google.com/p/go.net/ipv4"
 	"net"
 	"os"
+	"runtime"
 	"testing"
 )
 
-var udpMultipleGroupListenerTests = []struct {
-	gaddr *net.UDPAddr
-}{
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}}, // see RFC 4727
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)}}, // see RFC 4727
-	{&net.UDPAddr{IP: net.IPv4(224, 0, 0, 254)}}, // see RFC 4727
+var udpMultipleGroupListenerTests = []net.Addr{
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}, // see RFC 4727
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)},
+	&net.UDPAddr{IP: net.IPv4(224, 0, 0, 254)},
 }
 
-func TestUDPSingleConnWithMultipleGroupListeners(t *testing.T) {
+func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
 
-	for _, tt := range udpMultipleGroupListenerTests {
-		// listen to a wildcard address with no reusable port
-		c, err := net.ListenPacket("udp4", "0.0.0.0:0")
+	for _, gaddr := range udpMultipleGroupListenerTests {
+		c, err := net.ListenPacket("udp4", "0.0.0.0:0") // wildcard address with no reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
 		defer c.Close()
 
 		p := ipv4.NewPacketConn(c)
-
 		var mift []*net.Interface
+
 		ift, err := net.Interfaces()
 		if err != nil {
 			t.Fatalf("net.Interfaces failed: %v", err)
@@ -45,34 +45,36 @@ func TestUDPSingleConnWithMultipleGroupListeners(t *testing.T) {
 			if _, ok := isMulticastAvailable(&ifi); !ok {
 				continue
 			}
-			if err := p.JoinGroup(&ifi, tt.gaddr); err != nil {
-				t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+			if err := p.JoinGroup(&ifi, gaddr); err != nil {
+				t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
 			}
 			mift = append(mift, &ift[i])
 		}
 		for _, ifi := range mift {
-			if err := p.LeaveGroup(ifi, tt.gaddr); err != nil {
-				t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+			if err := p.LeaveGroup(ifi, gaddr); err != nil {
+				t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
 			}
 		}
 	}
 }
 
-func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
+func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
 
-	for _, tt := range udpMultipleGroupListenerTests {
-		// listen to a group address, actually a wildcard address
-		// with reusable port
-		c1, err := net.ListenPacket("udp4", "224.0.0.0:1024") // see RFC 4727
+	for _, gaddr := range udpMultipleGroupListenerTests {
+		c1, err := net.ListenPacket("udp4", "224.0.0.0:1024") // wildcard address with reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
 		defer c1.Close()
 
-		c2, err := net.ListenPacket("udp4", "224.0.0.0:1024") // see RFC 4727
+		c2, err := net.ListenPacket("udp4", "224.0.0.0:1024") // wildcard address with reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket failed: %v", err)
 		}
@@ -81,8 +83,8 @@ func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
 		var ps [2]*ipv4.PacketConn
 		ps[0] = ipv4.NewPacketConn(c1)
 		ps[1] = ipv4.NewPacketConn(c2)
-
 		var mift []*net.Interface
+
 		ift, err := net.Interfaces()
 		if err != nil {
 			t.Fatalf("net.Interfaces failed: %v", err)
@@ -92,70 +94,32 @@ func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
 				continue
 			}
 			for _, p := range ps {
-				if err := p.JoinGroup(&ifi, tt.gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+				if err := p.JoinGroup(&ifi, gaddr); err != nil {
+					t.Fatalf("ipv4.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
 				}
 			}
 			mift = append(mift, &ift[i])
 		}
 		for _, ifi := range mift {
 			for _, p := range ps {
-				if err := p.LeaveGroup(ifi, tt.gaddr); err != nil {
-					t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", tt.gaddr, ifi, err)
+				if err := p.LeaveGroup(ifi, gaddr); err != nil {
+					t.Fatalf("ipv4.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
 				}
 			}
 		}
 	}
 }
 
-func TestIPSingleConnWithSingleGroupListener(t *testing.T) {
-	if testing.Short() || !*testExternal {
-		t.Skip("to avoid external network")
+func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
 	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	// listen to a wildcard address
-	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	r, err := ipv4.NewRawConn(c)
-	if err != nil {
-		t.Fatalf("ipv4.RawConn failed: %v", err)
-	}
-
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
-	var mift []*net.Interface
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
-	}
-	for i, ifi := range ift {
-		if _, ok := isMulticastAvailable(&ifi); !ok {
-			continue
-		}
-		if err := r.JoinGroup(&ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
-		}
-		mift = append(mift, &ift[i])
-	}
-	for _, ifi := range mift {
-		if err := r.LeaveGroup(ifi, gaddr); err != nil {
-			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", ifi, err)
-		}
-	}
-}
-
-func TestUDPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
 
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
 	type ml struct {
 		c   *ipv4.PacketConn
 		ifi *net.Interface
@@ -171,26 +135,29 @@ func TestUDPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		if !ok {
 			continue
 		}
-		// listen to a unicast interface address
-		c, err := net.ListenPacket("udp4", ip.String()+":"+"1024") // see RFC 4727
+		c, err := net.ListenPacket("udp4", ip.String()+":"+"1024") // unicast address with non-reusable port
 		if err != nil {
 			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
 		}
 		defer c.Close()
 		p := ipv4.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, gaddr); err != nil {
+		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.PacketConn.JoinGroup on %v failed: %v", ifi, err)
 		}
 		mlt = append(mlt, &ml{p, &ift[i]})
 	}
 	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, gaddr); err != nil {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
 		}
 	}
 }
 
-func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
+func TestIPSingleRawConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
 	if testing.Short() || !*testExternal {
 		t.Skip("to avoid external network")
 	}
@@ -198,7 +165,52 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		t.Skip("must be root")
 	}
 
-	gaddr := &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") // wildcard address
+	if err != nil {
+		t.Fatalf("net.ListenPacket failed: %v", err)
+	}
+	defer c.Close()
+
+	r, err := ipv4.NewRawConn(c)
+	if err != nil {
+		t.Fatalf("ipv4.RawConn failed: %v", err)
+	}
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
+	var mift []*net.Interface
+
+	ift, err := net.Interfaces()
+	if err != nil {
+		t.Fatalf("net.Interfaces failed: %v", err)
+	}
+	for i, ifi := range ift {
+		if _, ok := isMulticastAvailable(&ifi); !ok {
+			continue
+		}
+		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
+		}
+		mift = append(mift, &ift[i])
+	}
+	for _, ifi := range mift {
+		if err := r.LeaveGroup(ifi, &gaddr); err != nil {
+			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", ifi, err)
+		}
+	}
+}
+
+func TestIPPerInterfaceSingleRawConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
+	if testing.Short() || !*testExternal {
+		t.Skip("to avoid external network")
+	}
+	if os.Getuid() != 0 {
+		t.Skip("must be root")
+	}
+
+	gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727
 	type ml struct {
 		c   *ipv4.RawConn
 		ifi *net.Interface
@@ -214,8 +226,7 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		if !ok {
 			continue
 		}
-		// listen to a unicast interface address
-		c, err := net.ListenPacket("ip4:253", ip.String()) // see RFC 4727
+		c, err := net.ListenPacket("ip4:253", ip.String()) // unicast address
 		if err != nil {
 			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
 		}
@@ -224,13 +235,13 @@ func TestIPPerInterfaceSingleConnWithSingleGroupListener(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ipv4.NewRawConn failed: %v", err)
 		}
-		if err := r.JoinGroup(&ifi, gaddr); err != nil {
+		if err := r.JoinGroup(&ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.RawConn.JoinGroup on %v failed: %v", ifi, err)
 		}
 		mlt = append(mlt, &ml{r, &ift[i]})
 	}
 	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, gaddr); err != nil {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
 			t.Fatalf("ipv4.RawConn.LeaveGroup on %v failed: %v", m.ifi, err)
 		}
 	}

third_party/code.google.com/p/go.net/ipv4/packet.go

@@ -72,7 +72,7 @@ func slicePacket(b []byte) (h, p []byte, err error) {
 //	Checksum      = platform sets an appropriate value if Checksum is zero
 //	Src           = platform sets an appropriate value if Src is nil
 //	Dst           = <must be specified>
-//	h.Options     = optional
+//	Options       = optional
 func (c *packetHandler) WriteTo(h *Header, p []byte, cm *ControlMessage) error {
 	if !c.ok() {
 		return syscall.EINVAL

third_party/code.google.com/p/go.net/ipv6/icmp.go

@@ -21,26 +21,27 @@ func (typ ICMPType) String() string {
 // packets.
 type ICMPFilter struct {
 	mu sync.RWMutex
-	rawICMPFilter
+	sysICMPFilter
 }
 
 // Set sets the ICMP type and filter action to the filter.
 func (f *ICMPFilter) Set(typ ICMPType, block bool) {
 	f.mu.Lock()
-	defer f.mu.Unlock()
 	f.set(typ, block)
+	f.mu.Unlock()
 }
 
 // SetAll sets the filter action to the filter.
 func (f *ICMPFilter) SetAll(block bool) {
 	f.mu.Lock()
-	defer f.mu.Unlock()
 	f.setAll(block)
+	f.mu.Unlock()
 }
 
 // WillBlock reports whether the ICMP type will be blocked.
 func (f *ICMPFilter) WillBlock(typ ICMPType) bool {
 	f.mu.RLock()
-	defer f.mu.RUnlock()
-	return f.willBlock(typ)
+	ok := f.willBlock(typ)
+	f.mu.RUnlock()
+	return ok
 }

third_party/code.google.com/p/go.net/ipv6/icmp_bsd.go

@@ -6,13 +6,11 @@
 
 package ipv6
 
-import "syscall"
-
-type rawICMPFilter struct {
-	syscall.ICMPv6Filter
+type sysICMPFilter struct {
+	Filt [8]uint32
 }
 
-func (f *rawICMPFilter) set(typ ICMPType, block bool) {
+func (f *sysICMPFilter) set(typ ICMPType, block bool) {
 	if block {
 		f.Filt[typ>>5] &^= 1 << (uint32(typ) & 31)
 	} else {
@@ -20,7 +18,7 @@ func (f *rawICMPFilter) set(typ ICMPType, block bool) {
 	}
 }
 
-func (f *rawICMPFilter) setAll(block bool) {
+func (f *sysICMPFilter) setAll(block bool) {
 	for i := range f.Filt {
 		if block {
 			f.Filt[i] = 0
@@ -30,6 +28,6 @@ func (f *rawICMPFilter) setAll(block bool) {
 	}
 }
 
-func (f *rawICMPFilter) willBlock(typ ICMPType) bool {
+func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
 	return f.Filt[typ>>5]&(1<<(uint32(typ)&31)) == 0
 }

third_party/code.google.com/p/go.net/ipv6/icmp_linux.go

@@ -4,13 +4,11 @@
 
 package ipv6
 
-import "syscall"
-
-type rawICMPFilter struct {
-	syscall.ICMPv6Filter
+type sysICMPFilter struct {
+	Data [8]uint32
 }
 
-func (f *rawICMPFilter) set(typ ICMPType, block bool) {
+func (f *sysICMPFilter) set(typ ICMPType, block bool) {
 	if block {
 		f.Data[typ>>5] |= 1 << (uint32(typ) & 31)
 	} else {
@@ -18,7 +16,7 @@ func (f *rawICMPFilter) set(typ ICMPType, block bool) {
 	}
 }
 
-func (f *rawICMPFilter) setAll(block bool) {
+func (f *sysICMPFilter) setAll(block bool) {
 	for i := range f.Data {
 		if block {
 			f.Data[i] = 1<<32 - 1
@@ -28,6 +26,6 @@ func (f *rawICMPFilter) setAll(block bool) {
 	}
 }
 
-func (f *rawICMPFilter) willBlock(typ ICMPType) bool {
+func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
 	return f.Data[typ>>5]&(1<<(uint32(typ)&31)) != 0
 }

third_party/code.google.com/p/go.net/ipv6/icmp_plan9.go

@@ -4,19 +4,19 @@
 
 package ipv6
 
-type rawICMPFilter struct {
+type sysICMPFilter struct {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) set(typ ICMPType, block bool) {
+func (f *sysICMPFilter) set(typ ICMPType, block bool) {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) setAll(block bool) {
+func (f *sysICMPFilter) setAll(block bool) {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) willBlock(typ ICMPType) bool {
+func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
 	// TODO(mikio): Implement this
 	return false
 }

third_party/code.google.com/p/go.net/ipv6/icmp_windows.go

@@ -4,19 +4,19 @@
 
 package ipv6
 
-type rawICMPFilter struct {
+type sysICMPFilter struct {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) set(typ ICMPType, block bool) {
+func (f *sysICMPFilter) set(typ ICMPType, block bool) {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) setAll(block bool) {
+func (f *sysICMPFilter) setAll(block bool) {
 	// TODO(mikio): Implement this
 }
 
-func (f *rawICMPFilter) willBlock(typ ICMPType) bool {
+func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
 	// TODO(mikio): Implement this
 	return false
 }

third_party/code.google.com/p/go.net/ipv6/mockicmp_test.go

@@ -7,8 +7,22 @@ package ipv6_test
 import (
 	"code.google.com/p/go.net/ipv6"
 	"errors"
+	"net"
 )
 
+const (
+	ipv6PseudoHeaderLen  = 2*net.IPv6len + 8
+	ianaProtocolIPv6ICMP = 58
+)
+
+func ipv6PseudoHeader(src, dst net.IP, nextHeader int) []byte {
+	b := make([]byte, ipv6PseudoHeaderLen)
+	copy(b[:net.IPv6len], src)
+	copy(b[net.IPv6len:], dst)
+	b[len(b)-1] = byte(nextHeader)
+	return b
+}
+
 // icmpMessage represents an ICMP message.
 type icmpMessage struct {
 	Type     ipv6.ICMPType   // type
@@ -25,8 +39,11 @@ type icmpMessageBody interface {
 
 // Marshal returns the binary enconding of the ICMP echo request or
 // reply message m.
-func (m *icmpMessage) Marshal() ([]byte, error) {
+func (m *icmpMessage) Marshal(psh []byte) ([]byte, error) {
 	b := []byte{byte(m.Type), byte(m.Code), 0, 0}
+	if psh != nil {
+		b = append(psh, b...)
+	}
 	if m.Body != nil && m.Body.Len() != 0 {
 		mb, err := m.Body.Marshal()
 		if err != nil {
@@ -34,10 +51,11 @@ func (m *icmpMessage) Marshal() ([]byte, error) {
 		}
 		b = append(b, mb...)
 	}
-	switch m.Type {
-	case ipv6.ICMPTypeEchoRequest, ipv6.ICMPTypeEchoReply:
+	if psh == nil {
 		return b, nil
 	}
+	off, l := 2*net.IPv6len, len(b)-len(psh)
+	b[off], b[off+1], b[off+2], b[off+3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l)
 	csumcv := len(b) - 1 // checksum coverage
 	s := uint32(0)
 	for i := 0; i < csumcv; i += 2 {
@@ -50,9 +68,9 @@ func (m *icmpMessage) Marshal() ([]byte, error) {
 	s = s + s>>16
 	// Place checksum back in header; using ^= avoids the
 	// assumption the checksum bytes are zero.
-	b[2] ^= byte(^s)
-	b[3] ^= byte(^s >> 8)
-	return b, nil
+	b[len(psh)+2] ^= byte(^s)
+	b[len(psh)+3] ^= byte(^s >> 8)
+	return b[len(psh):], nil
 }
 
 // parseICMPMessage parses b as an ICMP message.

third_party/code.google.com/p/go.net/ipv6/multicast_test.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"runtime"
 	"testing"
+	"time"
 )
 
 func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
@@ -44,15 +45,22 @@ func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
 	}
 
 	p := ipv6.NewPacketConn(c)
+	defer p.Close()
 	if err := p.JoinGroup(ifi, dst); err != nil {
 		t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
 	}
 	if err := p.SetMulticastInterface(ifi); err != nil {
 		t.Fatalf("ipv6.PacketConn.SetMulticastInterface failed: %v", err)
 	}
+	if _, err := p.MulticastInterface(); err != nil {
+		t.Fatalf("ipv6.PacketConn.MulticastInterface failed: %v", err)
+	}
 	if err := p.SetMulticastLoopback(true); err != nil {
 		t.Fatalf("ipv6.PacketConn.SetMulticastLoopback failed: %v", err)
 	}
+	if _, err := p.MulticastLoopback(); err != nil {
+		t.Fatalf("ipv6.PacketConn.MulticastLoopback failed: %v", err)
+	}
 
 	cm := ipv6.ControlMessage{
 		TrafficClass: DiffServAF11 | CongestionExperienced,
@@ -64,6 +72,9 @@ func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
 		if err := p.SetControlMessage(cf, toggle); err != nil {
 			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
 		}
+		if err := p.SetDeadline(time.Now().Add(time.Millisecond * 200)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetDeadline failed: %v", err)
+		}
 		cm.HopLimit = i + 1
 		if _, err := p.WriteTo([]byte("HELLO-R-U-THERE"), &cm, dst); err != nil {
 			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
@@ -104,16 +115,24 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 		t.Fatalf("net.ResolveIPAddr failed: %v", err)
 	}
 
+	pshicmp := ipv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP, ianaProtocolIPv6ICMP)
 	p := ipv6.NewPacketConn(c)
+	defer p.Close()
 	if err := p.JoinGroup(ifi, dst); err != nil {
 		t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
 	}
 	if err := p.SetMulticastInterface(ifi); err != nil {
 		t.Fatalf("ipv6.PacketConn.SetMulticastInterface failed: %v", err)
 	}
+	if _, err := p.MulticastInterface(); err != nil {
+		t.Fatalf("ipv6.PacketConn.MulticastInterface failed: %v", err)
+	}
 	if err := p.SetMulticastLoopback(true); err != nil {
 		t.Fatalf("ipv6.PacketConn.SetMulticastLoopback failed: %v", err)
 	}
+	if _, err := p.MulticastLoopback(); err != nil {
+		t.Fatalf("ipv6.PacketConn.MulticastLoopback failed: %v", err)
+	}
 
 	cm := ipv6.ControlMessage{
 		TrafficClass: DiffServAF11 | CongestionExperienced,
@@ -128,20 +147,35 @@ func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
 		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
 	}
 
+	var psh []byte
 	for i, toggle := range []bool{true, false, true} {
+		if toggle {
+			psh = nil
+			if err := p.SetChecksum(true, 2); err != nil {
+				t.Fatalf("ipv6.PacketConn.SetChecksum failed: %v", err)
+			}
+		} else {
+			psh = pshicmp
+			// Some platforms never allow to disable the
+			// kernel checksum processing.
+			p.SetChecksum(false, -1)
+		}
 		wb, err := (&icmpMessage{
 			Type: ipv6.ICMPTypeEchoRequest, Code: 0,
 			Body: &icmpEcho{
 				ID: os.Getpid() & 0xffff, Seq: i + 1,
 				Data: []byte("HELLO-R-U-THERE"),
 			},
-		}).Marshal()
+		}).Marshal(psh)
 		if err != nil {
 			t.Fatalf("icmpMessage.Marshal failed: %v", err)
 		}
 		if err := p.SetControlMessage(cf, toggle); err != nil {
 			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
 		}
+		if err := p.SetDeadline(time.Now().Add(time.Millisecond * 200)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetDeadline failed: %v", err)
+		}
 		cm.HopLimit = i + 1
 		if _, err := p.WriteTo(wb, &cm, dst); err != nil {
 			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)

third_party/code.google.com/p/go.net/ipv6/multicastlistener_test.go

@@ -59,7 +59,7 @@ func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
 	}
 }
 
-func TestUDPMultipleConnWithMultipleGroupListeners(t *testing.T) {
+func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
 	switch runtime.GOOS {
 	case "plan9", "windows":
 		t.Skipf("not supported on %q", runtime.GOOS)
@@ -120,7 +120,7 @@ func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		t.Skip("ipv6 is not supported")
 	}
 
-	gaddr := &net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
+	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
 	type ml struct {
 		c   *ipv6.PacketConn
 		ifi *net.Interface
@@ -142,13 +142,13 @@ func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		}
 		defer c.Close()
 		p := ipv6.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, gaddr); err != nil {
+		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
 			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
 		}
 		mlt = append(mlt, &ml{p, &ift[i]})
 	}
 	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, gaddr); err != nil {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
 			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
 		}
 	}
@@ -166,14 +166,14 @@ func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		t.Skip("must be root")
 	}
 
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::")
+	c, err := net.ListenPacket("ip6:ipv6-icmp", "::") // wildcard address
 	if err != nil {
 		t.Fatalf("net.ListenPacket failed: %v", err)
 	}
 	defer c.Close()
 
 	p := ipv6.NewPacketConn(c)
-	gaddr := &net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
+	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
 	var mift []*net.Interface
 
 	ift, err := net.Interfaces()
@@ -184,14 +184,60 @@ func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
 		if _, ok := isMulticastAvailable(&ifi); !ok {
 			continue
 		}
-		if err := p.JoinGroup(&ifi, gaddr); err != nil {
+		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
 			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
 		}
 		mift = append(mift, &ift[i])
 	}
 	for _, ifi := range mift {
-		if err := p.LeaveGroup(ifi, gaddr); err != nil {
+		if err := p.LeaveGroup(ifi, &gaddr); err != nil {
 			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", ifi, err)
 		}
 	}
 }
+
+func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
+	switch runtime.GOOS {
+	case "darwin", "plan9", "windows":
+		t.Skipf("not supported on %q", runtime.GOOS)
+	}
+	if !supportsIPv6 {
+		t.Skip("ipv6 is not supported")
+	}
+	if os.Getuid() != 0 {
+		t.Skip("must be root")
+	}
+
+	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
+	type ml struct {
+		c   *ipv6.PacketConn
+		ifi *net.Interface
+	}
+	var mlt []*ml
+
+	ift, err := net.Interfaces()
+	if err != nil {
+		t.Fatalf("net.Interfaces failed: %v", err)
+	}
+	for i, ifi := range ift {
+		ip, ok := isMulticastAvailable(&ifi)
+		if !ok {
+			continue
+		}
+		c, err := net.ListenPacket("ip6:ipv6-icmp", fmt.Sprintf("%s%%%s", ip.String(), ifi.Name)) // unicast address
+		if err != nil {
+			t.Fatalf("net.ListenPacket failed: %v", err)
+		}
+		defer c.Close()
+		p := ipv6.NewPacketConn(c)
+		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
+			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
+		}
+		mlt = append(mlt, &ml{p, &ift[i]})
+	}
+	for _, m := range mlt {
+		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
+			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
+		}
+	}
+}

third_party/code.google.com/p/go.net/ipv6/sockopt_rfc3493_bsd.go

@@ -8,12 +8,13 @@ package ipv6
 
 import (
 	"os"
-	"syscall"
+	"unsafe"
 )
 
 func setIPv6Checksum(fd int, on bool, offset int) error {
 	if !on {
 		offset = -1
 	}
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_CHECKSUM, offset))
+	v := int32(offset)
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), 4))
 }

third_party/code.google.com/p/go.net/ipv6/sockopt_rfc3493_linux.go

@@ -6,12 +6,13 @@ package ipv6
 
 import (
 	"os"
-	"syscall"
+	"unsafe"
 )
 
 func setIPv6Checksum(fd int, on bool, offset int) error {
 	if !on {
 		offset = -1
 	}
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolReserved, syscall.IPV6_CHECKSUM, offset))
+	v := int32(offset)
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolReserved, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), 4))
 }

third_party/code.google.com/p/go.net/ipv6/sockopt_rfc3493_unix.go

@@ -9,66 +9,74 @@ package ipv6
 import (
 	"net"
 	"os"
-	"syscall"
+	"unsafe"
 )
 
 func ipv6TrafficClass(fd int) (int, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_TCLASS)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptTrafficClass, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return 0, os.NewSyscallError("getsockopt", err)
 	}
-	return v, nil
+	return int(v), nil
 }
 
 func setIPv6TrafficClass(fd, v int) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_TCLASS, v))
+	vv := int32(v)
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptTrafficClass, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6HopLimit(fd int) (int, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_UNICAST_HOPS)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return 0, os.NewSyscallError("getsockopt", err)
 	}
-	return v, nil
+	return int(v), nil
 }
 
 func setIPv6HopLimit(fd, v int) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_UNICAST_HOPS, v))
+	vv := int32(v)
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6Checksum(fd int) (bool, int, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_CHECKSUM)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return false, 0, os.NewSyscallError("getsockopt", err)
 	}
 	on := true
 	if v == -1 {
 		on = false
 	}
-	return on, v, nil
+	return on, int(v), nil
 }
 
 func ipv6MulticastHopLimit(fd int) (int, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_HOPS)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return 0, os.NewSyscallError("getsockopt", err)
 	}
-	return v, nil
+	return int(v), nil
 }
 
 func setIPv6MulticastHopLimit(fd, v int) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_HOPS, v))
+	vv := int32(v)
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6MulticastInterface(fd int) (*net.Interface, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_IF)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return nil, os.NewSyscallError("getsockopt", err)
 	}
 	if v == 0 {
 		return nil, nil
 	}
-	ifi, err := net.InterfaceByIndex(v)
+	ifi, err := net.InterfaceByIndex(int(v))
 	if err != nil {
 		return nil, err
 	}
@@ -76,39 +84,41 @@ func ipv6MulticastInterface(fd int) (*net.Interface, error) {
 }
 
 func setIPv6MulticastInterface(fd int, ifi *net.Interface) error {
-	var v int
+	var v int32
 	if ifi != nil {
-		v = ifi.Index
+		v = int32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_IF, v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, uintptr(unsafe.Pointer(&v)), 4))
 }
 
 func ipv6MulticastLoopback(fd int) (bool, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_LOOP)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return false, os.NewSyscallError("getsockopt", err)
 	}
 	return v == 1, nil
 }
 
 func setIPv6MulticastLoopback(fd int, v bool) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_LOOP, boolint(v)))
+	vv := int32(boolint(v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func joinIPv6Group(fd int, ifi *net.Interface, grp net.IP) error {
-	mreq := syscall.IPv6Mreq{}
-	copy(mreq.Multiaddr[:], grp)
+	mreq := sysMulticastReq{}
+	copy(mreq.IP[:], grp)
 	if ifi != nil {
-		mreq.Interface = uint32(ifi.Index)
+		mreq.IfIndex = uint32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptIPv6Mreq(fd, ianaProtocolIPv6, syscall.IPV6_JOIN_GROUP, &mreq))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptJoinGroup, uintptr(unsafe.Pointer(&mreq)), sysSizeofMulticastReq))
 }
 
 func leaveIPv6Group(fd int, ifi *net.Interface, grp net.IP) error {
-	mreq := syscall.IPv6Mreq{}
-	copy(mreq.Multiaddr[:], grp)
+	mreq := sysMulticastReq{}
+	copy(mreq.IP[:], grp)
 	if ifi != nil {
-		mreq.Interface = uint32(ifi.Index)
+		mreq.IfIndex = uint32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptIPv6Mreq(fd, ianaProtocolIPv6, syscall.IPV6_LEAVE_GROUP, &mreq))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptLeaveGroup, uintptr(unsafe.Pointer(&mreq)), sysSizeofMulticastReq))
 }

third_party/code.google.com/p/go.net/ipv6/sockopt_rfc3493_windows.go

@@ -24,7 +24,7 @@ func setIPv6TrafficClass(fd syscall.Handle, v int) error {
 func ipv6HopLimit(fd syscall.Handle) (int, error) {
 	var v int32
 	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, syscall.IPV6_UNICAST_HOPS, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
+	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
 		return 0, os.NewSyscallError("getsockopt", err)
 	}
 	return int(v), nil
@@ -32,7 +32,7 @@ func ipv6HopLimit(fd syscall.Handle) (int, error) {
 
 func setIPv6HopLimit(fd syscall.Handle, v int) error {
 	vv := int32(v)
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_UNICAST_HOPS, (*byte)(unsafe.Pointer(&vv)), 4))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, (*byte)(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6Checksum(fd syscall.Handle) (bool, int, error) {
@@ -43,7 +43,7 @@ func ipv6Checksum(fd syscall.Handle) (bool, int, error) {
 func ipv6MulticastHopLimit(fd syscall.Handle) (int, error) {
 	var v int32
 	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_HOPS, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
+	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
 		return 0, os.NewSyscallError("getsockopt", err)
 	}
 	return int(v), nil
@@ -51,13 +51,13 @@ func ipv6MulticastHopLimit(fd syscall.Handle) (int, error) {
 
 func setIPv6MulticastHopLimit(fd syscall.Handle, v int) error {
 	vv := int32(v)
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_HOPS, (*byte)(unsafe.Pointer(&vv)), 4))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, (*byte)(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6MulticastInterface(fd syscall.Handle) (*net.Interface, error) {
 	var v int32
 	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_IF, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
+	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
 		return nil, os.NewSyscallError("getsockopt", err)
 	}
 	if v == 0 {
@@ -75,13 +75,13 @@ func setIPv6MulticastInterface(fd syscall.Handle, ifi *net.Interface) error {
 	if ifi != nil {
 		v = int32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_IF, (*byte)(unsafe.Pointer(&v)), 4))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, (*byte)(unsafe.Pointer(&v)), 4))
 }
 
 func ipv6MulticastLoopback(fd syscall.Handle) (bool, error) {
 	var v int32
 	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_LOOP, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
+	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
 		return false, os.NewSyscallError("getsockopt", err)
 	}
 	return v == 1, nil
@@ -89,25 +89,25 @@ func ipv6MulticastLoopback(fd syscall.Handle) (bool, error) {
 
 func setIPv6MulticastLoopback(fd syscall.Handle, v bool) error {
 	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_MULTICAST_LOOP, (*byte)(unsafe.Pointer(&vv)), 4))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, (*byte)(unsafe.Pointer(&vv)), 4))
 }
 
 func joinIPv6Group(fd syscall.Handle, ifi *net.Interface, grp net.IP) error {
-	mreq := syscall.IPv6Mreq{}
-	copy(mreq.Multiaddr[:], grp)
+	mreq := sysMulticastReq{}
+	copy(mreq.IP[:], grp)
 	if ifi != nil {
-		mreq.Interface = uint32(ifi.Index)
+		mreq.IfIndex = uint32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_JOIN_GROUP, (*byte)(unsafe.Pointer(&mreq)), int32(unsafe.Sizeof(mreq))))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptJoinGroup, (*byte)(unsafe.Pointer(&mreq)), int32(sysSizeofMulticastReq)))
 }
 
 func leaveIPv6Group(fd syscall.Handle, ifi *net.Interface, grp net.IP) error {
-	mreq := syscall.IPv6Mreq{}
-	copy(mreq.Multiaddr[:], grp)
+	mreq := sysMulticastReq{}
+	copy(mreq.IP[:], grp)
 	if ifi != nil {
-		mreq.Interface = uint32(ifi.Index)
+		mreq.IfIndex = uint32(ifi.Index)
 	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, syscall.IPV6_LEAVE_GROUP, (*byte)(unsafe.Pointer(&mreq)), int32(unsafe.Sizeof(mreq))))
+	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptLeaveGroup, (*byte)(unsafe.Pointer(&mreq)), int32(sysSizeofMulticastReq)))
 }
 
 func setIPv6Checksum(fd syscall.Handle, on bool, offset int) error {

third_party/code.google.com/p/go.net/ipv6/sockopt_rfc3542_unix.go

@@ -8,41 +8,83 @@ package ipv6
 
 import (
 	"os"
-	"syscall"
+	"unsafe"
 )
 
 func ipv6ReceiveTrafficClass(fd int) (bool, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVTCLASS)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveTrafficClass, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return false, os.NewSyscallError("getsockopt", err)
 	}
 	return v == 1, nil
 }
 
 func setIPv6ReceiveTrafficClass(fd int, v bool) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVTCLASS, boolint(v)))
+	vv := int32(boolint(v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveTrafficClass, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6ReceiveHopLimit(fd int) (bool, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVHOPLIMIT)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return false, os.NewSyscallError("getsockopt", err)
 	}
 	return v == 1, nil
 }
 
 func setIPv6ReceiveHopLimit(fd int, v bool) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVHOPLIMIT, boolint(v)))
+	vv := int32(boolint(v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
 }
 
 func ipv6ReceivePacketInfo(fd int) (bool, error) {
-	v, err := syscall.GetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVPKTINFO)
-	if err != nil {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePacketInfo, uintptr(unsafe.Pointer(&v)), &l); err != nil {
 		return false, os.NewSyscallError("getsockopt", err)
 	}
 	return v == 1, nil
 }
 
 func setIPv6ReceivePacketInfo(fd int, v bool) error {
-	return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, ianaProtocolIPv6, syscall.IPV6_RECVPKTINFO, boolint(v)))
+	vv := int32(boolint(v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePacketInfo, uintptr(unsafe.Pointer(&vv)), 4))
+}
+
+func ipv6PathMTU(fd int) (int, error) {
+	var v sysMTUInfo
+	l := sysSockoptLen(sysSizeofMTUInfo)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptPathMTU, uintptr(unsafe.Pointer(&v)), &l); err != nil {
+		return 0, os.NewSyscallError("getsockopt", err)
+	}
+	return int(v.MTU), nil
+}
+
+func ipv6ReceivePathMTU(fd int) (bool, error) {
+	var v int32
+	l := sysSockoptLen(4)
+	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePathMTU, uintptr(unsafe.Pointer(&v)), &l); err != nil {
+		return false, os.NewSyscallError("getsockopt", err)
+	}
+	return v == 1, nil
+}
+
+func setIPv6ReceivePathMTU(fd int, v bool) error {
+	vv := int32(boolint(v))
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePathMTU, uintptr(unsafe.Pointer(&vv)), 4))
+}
+
+func ipv6ICMPFilter(fd int) (*ICMPFilter, error) {
+	var v ICMPFilter
+	l := sysSockoptLen(sysSizeofICMPFilter)
+	if err := getsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&v.sysICMPFilter)), &l); err != nil {
+		return nil, os.NewSyscallError("getsockopt", err)
+	}
+	return &v, nil
+}
+
+func setIPv6ICMPFilter(fd int, f *ICMPFilter) error {
+	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&f.sysICMPFilter)), sysSizeofICMPFilter))
 }

third_party/code.google.com/p/go.net/ipv6/unicast_test.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"runtime"
 	"testing"
+	"time"
 )
 
 func benchmarkUDPListener() (net.PacketConn, net.Addr, error) {
@@ -106,6 +107,7 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 	}
 
 	p := ipv6.NewPacketConn(c)
+	defer p.Close()
 	cm := ipv6.ControlMessage{
 		TrafficClass: DiffServAF11 | CongestionExperienced,
 	}
@@ -120,10 +122,16 @@ func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
 		}
 		cm.HopLimit = i + 1
+		if err := p.SetWriteDeadline(time.Now().Add(time.Millisecond * 100)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
+		}
 		if _, err := p.WriteTo([]byte("HELLO-R-U-THERE"), &cm, dst); err != nil {
 			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
 		}
 		b := make([]byte, 128)
+		if err := p.SetReadDeadline(time.Now().Add(time.Millisecond * 100)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
+		}
 		if _, cm, _, err := p.ReadFrom(b); err != nil {
 			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
 		} else {
@@ -155,7 +163,9 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 		t.Fatalf("net.ResolveIPAddr failed: %v", err)
 	}
 
+	pshicmp := ipv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP, ianaProtocolIPv6ICMP)
 	p := ipv6.NewPacketConn(c)
+	defer p.Close()
 	cm := ipv6.ControlMessage{TrafficClass: DiffServAF11 | CongestionExperienced}
 	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagInterface | ipv6.FlagPathMTU
 	ifi := loopbackInterface()
@@ -170,14 +180,26 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
 	}
 
+	var psh []byte
 	for i, toggle := range []bool{true, false, true} {
+		if toggle {
+			psh = nil
+			if err := p.SetChecksum(true, 2); err != nil {
+				t.Fatalf("ipv6.PacketConn.SetChecksum failed: %v", err)
+			}
+		} else {
+			psh = pshicmp
+			// Some platforms never allow to disable the
+			// kernel checksum processing.
+			p.SetChecksum(false, -1)
+		}
 		wb, err := (&icmpMessage{
 			Type: ipv6.ICMPTypeEchoRequest, Code: 0,
 			Body: &icmpEcho{
 				ID: os.Getpid() & 0xffff, Seq: i + 1,
 				Data: []byte("HELLO-R-U-THERE"),
 			},
-		}).Marshal()
+		}).Marshal(psh)
 		if err != nil {
 			t.Fatalf("icmpMessage.Marshal failed: %v", err)
 		}
@@ -185,10 +207,16 @@ func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
 		}
 		cm.HopLimit = i + 1
+		if err := p.SetWriteDeadline(time.Now().Add(time.Millisecond * 100)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
+		}
 		if _, err := p.WriteTo(wb, &cm, dst); err != nil {
 			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
 		}
 		b := make([]byte, 128)
+		if err := p.SetReadDeadline(time.Now().Add(time.Millisecond * 100)); err != nil {
+			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
+		}
 		if n, cm, _, err := p.ReadFrom(b); err != nil {
 			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
 		} else {

third_party/code.google.com/p/go.net/publicsuffix/list_test.go

@@ -99,19 +99,18 @@ var publicSuffixTestCases = []struct {
 	{"www.xxx.yyy.zzz.pb.ao", "pb.ao"},
 
 	// The .ar rules are:
-	// *.ar
-	// !congresodelalengua3.ar
-	// !educ.ar
-	// !gobiernoelectronico.ar
-	// !mecon.ar
-	// !nacion.ar
-	// !nic.ar
-	// !promocion.ar
-	// !retina.ar
-	// !uba.ar
+	// ar
+	// com.ar
+	// edu.ar
+	// gob.ar
+	// int.ar
+	// mil.ar
+	// net.ar
+	// org.ar
+	// tur.ar
 	// blogspot.com.ar
 	{"ar", "ar"},
-	{"www.ar", "www.ar"},
+	{"www.ar", "ar"},
 	{"nic.ar", "ar"},
 	{"www.nic.ar", "ar"},
 	{"com.ar", "com.ar"},
@@ -376,12 +375,12 @@ var eTLDPlusOneTestCases = []struct {
 	{"city.kobe.jp", "city.kobe.jp"},
 	{"www.city.kobe.jp", "city.kobe.jp"},
 	// TLD with a wildcard rule and exceptions.
-	{"om", ""},
-	{"test.om", ""},
-	{"b.test.om", "b.test.om"},
-	{"a.b.test.om", "b.test.om"},
-	{"songfest.om", "songfest.om"},
-	{"www.songfest.om", "songfest.om"},
+	{"ck", ""},
+	{"test.ck", ""},
+	{"b.test.ck", "b.test.ck"},
+	{"a.b.test.ck", "b.test.ck"},
+	{"www.ck", "www.ck"},
+	{"www.www.ck", "www.ck"},
 	// US K12.
 	{"us", ""},
 	{"test.us", "test.us"},

third_party/code.google.com/p/go.net/publicsuffix/table_test.go

@@ -148,16 +148,15 @@ var rules = [...]string{
 	"pb.ao",
 	"it.ao",
 	"aq",
-	"*.ar",
-	"!congresodelalengua3.ar",
-	"!educ.ar",
-	"!gobiernoelectronico.ar",
-	"!mecon.ar",
-	"!nacion.ar",
-	"!nic.ar",
-	"!promocion.ar",
-	"!retina.ar",
-	"!uba.ar",
+	"ar",
+	"com.ar",
+	"edu.ar",
+	"gob.ar",
+	"int.ar",
+	"mil.ar",
+	"net.ar",
+	"org.ar",
+	"tur.ar",
 	"e164.arpa",
 	"in-addr.arpa",
 	"ip6.arpa",
@@ -179,6 +178,7 @@ var rules = [...]string{
 	"gov.au",
 	"asn.au",
 	"id.au",
+	"csiro.au",
 	"info.au",
 	"conf.au",
 	"oz.au",
@@ -3770,12 +3770,16 @@ var rules = [...]string{
 	"info.nf",
 	"other.nf",
 	"store.nf",
-	"ac.ng",
+	"ng",
 	"com.ng",
 	"edu.ng",
-	"gov.ng",
+	"name.ng",
 	"net.ng",
 	"org.ng",
+	"sch.ng",
+	"gov.ng",
+	"mil.ng",
+	"mobi.ng",
 	"*.ni",
 	"nl",
 	"bv.nl",
@@ -4544,7 +4548,16 @@ var rules = [...]string{
 	"com.nr",
 	"nu",
 	"*.nz",
-	"*.om",
+	"om",
+	"co.om",
+	"com.om",
+	"edu.om",
+	"gov.om",
+	"med.om",
+	"museum.om",
+	"net.om",
+	"org.om",
+	"pro.om",
 	"!mediaphone.om",
 	"!nawrastelecom.om",
 	"!nawras.om",
@@ -5143,7 +5156,12 @@ var rules = [...]string{
 	"saotome.st",
 	"store.st",
 	"su",
-	"*.sv",
+	"sv",
+	"com.sv",
+	"edu.sv",
+	"gob.sv",
+	"org.sv",
+	"red.sv",
 	"sx",
 	"gov.sx",
 	"sy",
@@ -5709,7 +5727,79 @@ var rules = [...]string{
 	"*.za",
 	"*.zm",
 	"*.zw",
+	"xn--80asehdb",
+	"xn--80aswg",
+	"xn--ngbc5azd",
+	"xn--unup4y",
+	"xn--vhquv",
+	"camera",
+	"clothing",
+	"lighting",
+	"singles",
+	"ventures",
+	"voyage",
+	"guru",
+	"holdings",
+	"equipment",
+	"bike",
+	"estate",
+	"tattoo",
+	"xn--3ds443g",
+	"xn--fiq228c5hs",
+	"land",
+	"plumbing",
+	"contractors",
+	"sexy",
+	"menu",
+	"xn--rhqv96g",
+	"uno",
+	"gallery",
+	"technology",
+	"xn--3bst00m",
+	"reviews",
+	"guide",
+	"xn--6qq986b3xl",
+	"graphics",
+	"construction",
+	"onl",
+	"xn--q9jyb4c",
+	"diamonds",
+	"kiwi",
+	"enterprises",
+	"today",
+	"futbol",
+	"photography",
+	"tips",
+	"directory",
+	"kitchen",
+	"xn--6frz82g",
+	"kim",
+	"xn--cg4bki",
+	"monash",
+	"wed",
+	"pink",
+	"ruhr",
+	"buzz",
+	"careers",
+	"shoes",
+	"xn--4gbrim",
+	"career",
+	"otsuka",
+	"xn--fiq64b",
 	"cloudfront.net",
+	"compute.amazonaws.com",
+	"us-east-1.amazonaws.com",
+	"compute-1.amazonaws.com",
+	"z-1.compute-1.amazonaws.com",
+	"z-2.compute-1.amazonaws.com",
+	"ap-northeast-1.compute.amazonaws.com",
+	"ap-southeast-1.compute.amazonaws.com",
+	"ap-southeast-2.compute.amazonaws.com",
+	"eu-west-1.compute.amazonaws.com",
+	"sa-east-1.compute.amazonaws.com",
+	"us-gov-west-1.compute.amazonaws.com",
+	"us-west-1.compute.amazonaws.com",
+	"us-west-2.compute.amazonaws.com",
 	"elasticbeanstalk.com",
 	"elb.amazonaws.com",
 	"s3.amazonaws.com",
@@ -5760,6 +5850,8 @@ var rules = [...]string{
 	"uy.com",
 	"za.com",
 	"c.la",
+	"cloudcontrolled.com",
+	"cloudcontrolapp.com",
 	"co.ca",
 	"co.nl",
 	"co.no",
@@ -6043,7 +6135,13 @@ var rules = [...]string{
 	"webhop.org",
 	"worse-than.tv",
 	"writesthisblog.com",
+	"a.ssl.fastly.net",
+	"b.ssl.fastly.net",
+	"global.ssl.fastly.net",
+	"a.prod.fastly.net",
+	"global.prod.fastly.net",
 	"github.io",
+	"ro.com",
 	"appspot.com",
 	"blogspot.be",
 	"blogspot.bj",
@@ -6088,6 +6186,8 @@ var rules = [...]string{
 	"codespot.com",
 	"googleapis.com",
 	"googlecode.com",
+	"herokuapp.com",
+	"herokussl.com",
 	"iki.fi",
 	"biz.at",
 	"info.at",
@@ -6130,6 +6230,7 @@ var nodeLabels = [...]string{
 	"bg",
 	"bh",
 	"bi",
+	"bike",
 	"biz",
 	"bj",
 	"bm",
@@ -6138,10 +6239,14 @@ var nodeLabels = [...]string{
 	"br",
 	"bs",
 	"bt",
+	"buzz",
 	"bw",
 	"by",
 	"bz",
 	"ca",
+	"camera",
+	"career",
+	"careers",
 	"cat",
 	"cc",
 	"cd",
@@ -6151,10 +6256,13 @@ var nodeLabels = [...]string{
 	"ci",
 	"ck",
 	"cl",
+	"clothing",
 	"cm",
 	"cn",
 	"co",
 	"com",
+	"construction",
+	"contractors",
 	"coop",
 	"cr",
 	"cu",
@@ -6164,6 +6272,8 @@ var nodeLabels = [...]string{
 	"cy",
 	"cz",
 	"de",
+	"diamonds",
+	"directory",
 	"dj",
 	"dk",
 	"dm",
@@ -6173,8 +6283,11 @@ var nodeLabels = [...]string{
 	"edu",
 	"ee",
 	"eg",
+	"enterprises",
+	"equipment",
 	"er",
 	"es",
+	"estate",
 	"et",
 	"eu",
 	"fi",
@@ -6183,7 +6296,9 @@ var nodeLabels = [...]string{
 	"fm",
 	"fo",
 	"fr",
+	"futbol",
 	"ga",
+	"gallery",
 	"gd",
 	"ge",
 	"gf",
@@ -6197,14 +6312,18 @@ var nodeLabels = [...]string{
 	"gp",
 	"gq",
 	"gr",
+	"graphics",
 	"gs",
 	"gt",
 	"gu",
+	"guide",
+	"guru",
 	"gw",
 	"gy",
 	"hk",
 	"hm",
 	"hn",
+	"holdings",
 	"hr",
 	"ht",
 	"hu",
@@ -6229,6 +6348,9 @@ var nodeLabels = [...]string{
 	"kg",
 	"kh",
 	"ki",
+	"kim",
+	"kitchen",
+	"kiwi",
 	"km",
 	"kn",
 	"kp",
@@ -6237,9 +6359,11 @@ var nodeLabels = [...]string{
 	"ky",
 	"kz",
 	"la",
+	"land",
 	"lb",
 	"lc",
 	"li",
+	"lighting",
 	"lk",
 	"lr",
 	"ls",
@@ -6251,6 +6375,7 @@ var nodeLabels = [...]string{
 	"mc",
 	"md",
 	"me",
+	"menu",
 	"mg",
 	"mh",
 	"mil",
@@ -6260,6 +6385,7 @@ var nodeLabels = [...]string{
 	"mn",
 	"mo",
 	"mobi",
+	"monash",
 	"mp",
 	"mq",
 	"mr",
@@ -6287,14 +6413,19 @@ var nodeLabels = [...]string{
 	"nu",
 	"nz",
 	"om",
+	"onl",
 	"org",
+	"otsuka",
 	"pa",
 	"pe",
 	"pf",
 	"pg",
 	"ph",
+	"photography",
+	"pink",
 	"pk",
 	"pl",
+	"plumbing",
 	"pm",
 	"pn",
 	"post",
@@ -6306,18 +6437,23 @@ var nodeLabels = [...]string{
 	"py",
 	"qa",
 	"re",
+	"reviews",
 	"ro",
 	"rs",
 	"ru",
+	"ruhr",
 	"rw",
 	"sa",
 	"sb",
 	"sc",
 	"sd",
 	"se",
+	"sexy",
 	"sg",
 	"sh",
+	"shoes",
 	"si",
+	"singles",
 	"sk",
 	"sl",
 	"sm",
@@ -6330,18 +6466,22 @@ var nodeLabels = [...]string{
 	"sx",
 	"sy",
 	"sz",
+	"tattoo",
 	"tc",
 	"td",
+	"technology",
 	"tel",
 	"tf",
 	"tg",
 	"th",
+	"tips",
 	"tj",
 	"tk",
 	"tl",
 	"tm",
 	"tn",
 	"to",
+	"today",
 	"tr",
 	"travel",
 	"tt",
@@ -6351,23 +6491,37 @@ var nodeLabels = [...]string{
 	"ua",
 	"ug",
 	"uk",
+	"uno",
 	"us",
 	"uy",
 	"uz",
 	"va",
 	"vc",
 	"ve",
+	"ventures",
 	"vg",
 	"vi",
 	"vn",
+	"voyage",
 	"vu",
+	"wed",
 	"wf",
 	"ws",
+	"xn--3bst00m",
+	"xn--3ds443g",
 	"xn--3e0b707e",
 	"xn--45brj9c",
+	"xn--4gbrim",
 	"xn--54b7fta0cc",
+	"xn--6frz82g",
+	"xn--6qq986b3xl",
+	"xn--80asehdb",
+	"xn--80aswg",
 	"xn--90a3ac",
+	"xn--cg4bki",
 	"xn--clchc0ea0b2g2a9gcd",
+	"xn--fiq228c5hs",
+	"xn--fiq64b",
 	"xn--fiqs8s",
 	"xn--fiqz9s",
 	"xn--fpcrj9c3d",
@@ -6392,13 +6546,18 @@ var nodeLabels = [...]string{
 	"xn--mgbqly7c0a67fbc",
 	"xn--mgbqly7cvafr",
 	"xn--mgbtf8fl",
+	"xn--ngbc5azd",
 	"xn--nnx388a",
 	"xn--node",
 	"xn--o3cw4h",
 	"xn--ogbpf8fl",
 	"xn--p1ai",
 	"xn--pgbs0dh",
+	"xn--q9jyb4c",
+	"xn--rhqv96g",
 	"xn--s9brj9c",
+	"xn--unup4y",
+	"xn--vhquv",
 	"xn--wgbh1c",
 	"xn--wgbl6a",
 	"xn--xkc2al3hye2a",
@@ -6545,15 +6704,13 @@ var nodeLabels = [...]string{
 	"og",
 	"pb",
 	"com",
-	"congresodelalengua3",
-	"educ",
-	"gobiernoelectronico",
-	"mecon",
-	"nacion",
-	"nic",
-	"promocion",
-	"retina",
-	"uba",
+	"edu",
+	"gob",
+	"int",
+	"mil",
+	"net",
+	"org",
+	"tur",
 	"blogspot",
 	"e164",
 	"in-addr",
@@ -6574,6 +6731,7 @@ var nodeLabels = [...]string{
 	"asn",
 	"com",
 	"conf",
+	"csiro",
 	"edu",
 	"gov",
 	"id",
@@ -6910,6 +7068,8 @@ var nodeLabels = [...]string{
 	"blogspot",
 	"br",
 	"cechire",
+	"cloudcontrolapp",
+	"cloudcontrolled",
 	"cn",
 	"codespot",
 	"de",
@@ -6994,6 +7154,8 @@ var nodeLabels = [...]string{
 	"googlecode",
 	"gotdns",
 	"gr",
+	"herokuapp",
+	"herokussl",
 	"hobby-site",
 	"homelinux",
 	"homeunix",
@@ -7066,6 +7228,7 @@ var nodeLabels = [...]string{
 	"operaunite",
 	"qc",
 	"rhcloud",
+	"ro",
 	"ru",
 	"sa",
 	"saves-the-whales",
@@ -7082,6 +7245,8 @@ var nodeLabels = [...]string{
 	"uy",
 	"writesthisblog",
 	"za",
+	"compute",
+	"compute-1",
 	"elb",
 	"s3",
 	"s3-ap-northeast-1",
@@ -7102,6 +7267,17 @@ var nodeLabels = [...]string{
 	"s3-website-us-gov-west-1",
 	"s3-website-us-west-1",
 	"s3-website-us-west-2",
+	"us-east-1",
+	"ap-northeast-1",
+	"ap-southeast-1",
+	"ap-southeast-2",
+	"eu-west-1",
+	"sa-east-1",
+	"us-gov-west-1",
+	"us-west-1",
+	"us-west-2",
+	"z-1",
+	"z-2",
 	"ac",
 	"co",
 	"ed",
@@ -10279,6 +10455,7 @@ var nodeLabels = [...]string{
 	"dynalias",
 	"dynathome",
 	"endofinternet",
+	"fastly",
 	"from-az",
 	"from-co",
 	"from-la",
@@ -10309,6 +10486,13 @@ var nodeLabels = [...]string{
 	"uk",
 	"webhop",
 	"za",
+	"prod",
+	"ssl",
+	"a",
+	"global",
+	"a",
+	"b",
+	"global",
 	"arts",
 	"com",
 	"firm",
@@ -10319,12 +10503,15 @@ var nodeLabels = [...]string{
 	"rec",
 	"store",
 	"web",
-	"ac",
 	"com",
 	"edu",
 	"gov",
+	"mil",
+	"mobi",
+	"name",
 	"net",
 	"org",
+	"sch",
 	"blogspot",
 	"bv",
 	"co",
@@ -11106,12 +11293,21 @@ var nodeLabels = [...]string{
 	"shacknet",
 	"co",
 	"blogspot",
+	"co",
+	"com",
+	"edu",
+	"gov",
+	"med",
 	"mediaphone",
+	"museum",
 	"nawras",
 	"nawrastelecom",
+	"net",
 	"omanmobile",
 	"omanpost",
 	"omantel",
+	"org",
+	"pro",
 	"rakpetroleum",
 	"siemens",
 	"songfest",
@@ -11727,6 +11923,11 @@ var nodeLabels = [...]string{
 	"principe",
 	"saotome",
 	"store",
+	"com",
+	"edu",
+	"gob",
+	"org",
+	"red",
 	"gov",
 	"com",
 	"edu",

third_party/code.google.com/p/go.net/websocket/websocket_test.go

@@ -245,7 +245,7 @@ func TestWithTwoProtocol(t *testing.T) {
 func TestWithBadProtocol(t *testing.T) {
 	_, err := testWithProtocol(t, []string{"test"})
 	if err != ErrBadStatus {
-		t.Errorf("SubProto: expected %q, got %q", ErrBadStatus)
+		t.Errorf("SubProto: expected %v, got %v", ErrBadStatus, err)
 	}
 }